graphql 1.7.6 → 1.8.0

data/lib/graphql/language/parser.y

@@ -82,8 +82,7 @@ rule
     | EQUALS literal_value  { return val[1] }
 
   selection_set:
-      LCURLY RCURLY                { return [] }
-    | LCURLY selection_list RCURLY { return val[1] }
+      LCURLY selection_list RCURLY { return val[1] }
 
   selection_set_opt:
       /* none */    { return [] }
@@ -153,12 +152,8 @@ rule
     | operation_type
     | schema_keyword
 
-  name_list:
-      name             { return [make_node(:TypeName, name: val[0])] }
-    | name_list name   { val[0] << make_node(:TypeName, name: val[1]) }
-
   enum_value_definition:
-    enum_name directives_list_opt { return make_node(:EnumValueDefinition, name: val[0], directives: val[1], description: get_description(val[0])) }
+    enum_name directives_list_opt { return make_node(:EnumValueDefinition, name: val[0], directives: val[1], description: get_description(val[0]), position_source: val[0]) }
 
   enum_value_definitions:
       enum_value_definition                        { return [val[0]] }
@@ -281,7 +276,7 @@ rule
    | directive_definition
 
   schema_definition:
-      SCHEMA LCURLY operation_type_definition_list RCURLY { return make_node(:SchemaDefinition, position_source: val[0], **val[2]) }
+      SCHEMA directives_list_opt LCURLY operation_type_definition_list RCURLY { return make_node(:SchemaDefinition, position_source: val[0], directives: val[1], **val[3]) }
 
   operation_type_definition_list:
       operation_type_definition
@@ -307,11 +302,21 @@ rule
 
   implements_opt:
       /* none */ { return [] }
-    | IMPLEMENTS name_list { return val[1] }
+    | IMPLEMENTS AMP interfaces_list { return val[2] }
+    | IMPLEMENTS interfaces_list { return val[1] }
+    | IMPLEMENTS legacy_interfaces_list { return val[1] }
+
+  interfaces_list:
+      name                     { return [make_node(:TypeName, name: val[0], position_source: val[0])] }
+    | interfaces_list AMP name { val[0] << make_node(:TypeName, name: val[2], position_source: val[2]) }
+
+  legacy_interfaces_list:
+      name                        { return [make_node(:TypeName, name: val[0], position_source: val[0])] }
+    | legacy_interfaces_list name { val[0] << make_node(:TypeName, name: val[1], position_source: val[1]) }
 
   input_value_definition:
       name COLON type default_value_opt directives_list_opt {
-        return make_node(:InputValueDefinition, name: val[0], type: val[2], default_value: val[3], directives: val[4], description: get_description(val[0]))
+        return make_node(:InputValueDefinition, name: val[0], type: val[2], default_value: val[3], directives: val[4], description: get_description(val[0]), position_source: val[0])
       }
 
   input_value_definition_list:
@@ -324,11 +329,12 @@ rule
 
   field_definition:
       name arguments_definitions_opt COLON type directives_list_opt {
-        return make_node(:FieldDefinition, name: val[0], arguments: val[1], type: val[3], directives: val[4], description: get_description(val[0]))
+        return make_node(:FieldDefinition, name: val[0], arguments: val[1], type: val[3], directives: val[4], description: get_description(val[0]), position_source: val[0])
       }
 
   field_definition_list:
-      field_definition                       { return [val[0]] }
+    /* none */ { return [] }
+    | field_definition                       { return [val[0]] }
     | field_definition_list field_definition { val[0] << val[1] }
 
   interface_type_definition:

data/lib/graphql/language/printer.rb

@@ -0,0 +1,361 @@
+# frozen_string_literal: true
+module GraphQL
+  module Language
+    class Printer
+      # Turn an arbitrary AST node back into a string.
+      #
+      # @example Turning a document into a query string
+      #    document = GraphQL.parse(query_string)
+      #    GraphQL::Language::Printer.new.print(document)
+      #    # => "{ ... }"
+      #
+      #
+      # @example Building a custom printer
+      #
+      #  class MyPrinter < GraphQL::Language::Printer
+      #    def print_argument(arg)
+      #      "#{arg.name}: <HIDDEN>"
+      #    end
+      #  end
+      #
+      #  MyPrinter.new.print(document)
+      #  # => "mutation { pay(creditCard: <HIDDEN>) { success } }"
+      #
+      #
+      # @param indent [String] Whitespace to add to the printed node
+      # @return [String] Valid GraphQL for `node`
+      def print(node, indent: "")
+        print_node(node, indent: indent)
+      end
+
+      protected
+
+      def print_document(document)
+        document.definitions.map { |d| print_node(d) }.join("\n\n")
+      end
+
+      def print_argument(argument)
+        "#{argument.name}: #{print_node(argument.value)}".dup
+      end
+
+      def print_directive(directive)
+        out = "@#{directive.name}".dup
+
+        if directive.arguments.any?
+          out << "(#{directive.arguments.map { |a| print_argument(a) }.join(", ")})"
+        end
+
+        out
+      end
+
+      def print_enum(enum)
+        "#{enum.name}".dup
+      end
+
+      def print_null_value
+        "null".dup
+      end
+
+      def print_field(field, indent: "")
+        out = "#{indent}".dup
+        out << "#{field.alias}: " if field.alias
+        out << "#{field.name}"
+        out << "(#{field.arguments.map { |a| print_argument(a) }.join(", ")})" if field.arguments.any?
+        out << print_directives(field.directives)
+        out << print_selections(field.selections, indent: indent)
+        out
+      end
+
+      def print_fragment_definition(fragment_def, indent: "")
+        out = "#{indent}fragment #{fragment_def.name}".dup
+        if fragment_def.type
+          out << " on #{print_node(fragment_def.type)}"
+        end
+        out << print_directives(fragment_def.directives)
+        out << print_selections(fragment_def.selections, indent: indent)
+        out
+      end
+
+      def print_fragment_spread(fragment_spread, indent: "")
+        out = "#{indent}...#{fragment_spread.name}".dup
+        out << print_directives(fragment_spread.directives)
+        out
+      end
+
+      def print_inline_fragment(inline_fragment, indent: "")
+        out = "#{indent}...".dup
+        if inline_fragment.type
+          out << " on #{print_node(inline_fragment.type)}"
+        end
+        out << print_directives(inline_fragment.directives)
+        out << print_selections(inline_fragment.selections, indent: indent)
+        out
+      end
+
+      def print_input_object(input_object)
+        "{#{input_object.arguments.map { |a| "#{a.name}: #{print(a.value)}" }.join(", ")}}"
+      end
+
+      def print_list_type(list_type)
+        "[#{print_node(list_type.of_type)}]".dup
+      end
+
+      def print_non_null_type(non_null_type)
+        "#{print_node(non_null_type.of_type)}!".dup
+      end
+
+      def print_operation_definition(operation_definition, indent: "")
+        out = "#{indent}#{operation_definition.operation_type}".dup
+        out << " #{operation_definition.name}" if operation_definition.name
+
+        if operation_definition.variables.any?
+          out << "(#{operation_definition.variables.map { |v| print_variable_definition(v) }.join(", ")})"
+        end
+
+        out << print_directives(operation_definition.directives)
+        out << print_selections(operation_definition.selections, indent: indent)
+        out
+      end
+
+      def print_type_name(type_name)
+        "#{type_name.name}".dup
+      end
+
+      def print_variable_definition(variable_definition)
+        out = "$#{variable_definition.name}: #{print_node(variable_definition.type)}".dup
+        out << " = #{print_node(variable_definition.default_value)}" unless variable_definition.default_value.nil?
+        out
+      end
+
+      def print_variable_identifier(variable_identifier)
+        "$#{variable_identifier.name}".dup
+      end
+
+      def print_schema_definition(schema)
+        if (schema.query.nil? || schema.query == 'Query') &&
+           (schema.mutation.nil? || schema.mutation == 'Mutation') &&
+           (schema.subscription.nil? || schema.subscription == 'Subscription') &&
+           (schema.directives.none?)
+          return
+        end
+
+        out = "schema".dup
+        if schema.directives.any?
+          schema.directives.each do |dir|
+            out << "\n  "
+            out << print_node(dir)
+          end
+          out << "\n{"
+        else
+          out << " {\n"
+        end
+        out << "  query: #{schema.query}\n" if schema.query
+        out << "  mutation: #{schema.mutation}\n" if schema.mutation
+        out << "  subscription: #{schema.subscription}\n" if schema.subscription
+        out << "}"
+      end
+
+      def print_scalar_type_definition(scalar_type)
+        out = print_description(scalar_type)
+        out << "scalar #{scalar_type.name}"
+        out << print_directives(scalar_type.directives)
+      end
+
+      def print_object_type_definition(object_type)
+        out = print_description(object_type)
+        out << "type #{object_type.name}"
+        out << " implements " << object_type.interfaces.map(&:name).join(" & ") unless object_type.interfaces.empty?
+        out << print_directives(object_type.directives)
+        out << print_field_definitions(object_type.fields)
+      end
+
+      def print_input_value_definition(input_value)
+        out = "#{input_value.name}: #{print_node(input_value.type)}".dup
+        out << " = #{print_node(input_value.default_value)}" unless input_value.default_value.nil?
+        out << print_directives(input_value.directives)
+      end
+
+      def print_arguments(arguments, indent: "")
+        if arguments.all?{ |arg| !arg.description }
+          return "(#{arguments.map{ |arg| print_input_value_definition(arg) }.join(", ")})"
+        end
+
+        out = "(\n".dup
+        out << arguments.map.with_index{ |arg, i|
+          "#{print_description(arg, indent: "  " + indent, first_in_block: i == 0)}  #{indent}"\
+          "#{print_input_value_definition(arg)}"
+        }.join("\n")
+        out << "\n#{indent})"
+      end
+
+      def print_field_definition(field)
+        out = field.name.dup
+        unless field.arguments.empty?
+          out << print_arguments(field.arguments, indent: "  ")
+        end
+        out << ": #{print_node(field.type)}"
+        out << print_directives(field.directives)
+      end
+
+      def print_interface_type_definition(interface_type)
+        out = print_description(interface_type)
+        out << "interface #{interface_type.name}"
+        out << print_directives(interface_type.directives)
+        out << print_field_definitions(interface_type.fields)
+      end
+
+      def print_union_type_definition(union_type)
+        out = print_description(union_type)
+        out << "union #{union_type.name}"
+        out << print_directives(union_type.directives)
+        out << " = " + union_type.types.map(&:name).join(" | ")
+      end
+
+      def print_enum_type_definition(enum_type)
+        out = print_description(enum_type)
+        out << "enum #{enum_type.name}#{print_directives(enum_type.directives)} {\n"
+        enum_type.values.each.with_index do |value, i|
+          out << print_description(value, indent: '  ', first_in_block: i == 0)
+          out << print_enum_value_definition(value)
+        end
+        out << "}"
+      end
+
+      def print_enum_value_definition(enum_value)
+        out = "  #{enum_value.name}".dup
+        out << print_directives(enum_value.directives)
+        out << "\n"
+      end
+
+      def print_input_object_type_definition(input_object_type)
+        out = print_description(input_object_type)
+        out << "input #{input_object_type.name}"
+        out << print_directives(input_object_type.directives)
+        out << " {\n"
+        input_object_type.fields.each.with_index do |field, i|
+          out << print_description(field, indent: '  ', first_in_block: i == 0)
+          out << "  #{print_input_value_definition(field)}\n"
+        end
+        out << "}"
+      end
+
+      def print_directive_definition(directive)
+        out = print_description(directive)
+        out << "directive @#{directive.name}"
+
+        if directive.arguments.any?
+          out << print_arguments(directive.arguments)
+        end
+
+        out << " on #{directive.locations.join(' | ')}"
+      end
+
+      def print_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 print_field_definitions(fields)
+        out = " {\n".dup
+        fields.each.with_index do |field, i|
+          out << print_description(field, indent: '  ', first_in_block: i == 0)
+          out << "  #{print_field_definition(field)}\n"
+        end
+        out << "}"
+      end
+
+      def print_directives(directives)
+        if directives.any?
+          directives.map { |d| " #{print_directive(d)}" }.join
+        else
+          ""
+        end
+      end
+
+      def print_selections(selections, indent: "")
+        if selections.any?
+          out = " {\n".dup
+          selections.each do |selection|
+            out << print_node(selection, indent: indent + "  ") << "\n"
+          end
+          out << "#{indent}}"
+        else
+          ""
+        end
+      end
+
+      def print_node(node, indent: "")
+        case node
+        when Nodes::Document
+          print_document(node)
+        when Nodes::Argument
+          print_argument(node)
+        when Nodes::Directive
+          print_directive(node)
+        when Nodes::Enum
+          print_enum(node)
+        when Nodes::NullValue
+          print_null_value
+        when Nodes::Field
+          print_field(node, indent: indent)
+        when Nodes::FragmentDefinition
+          print_fragment_definition(node, indent: indent)
+        when Nodes::FragmentSpread
+          print_fragment_spread(node, indent: indent)
+        when Nodes::InlineFragment
+          print_inline_fragment(node, indent: indent)
+        when Nodes::InputObject
+          print_input_object(node)
+        when Nodes::ListType
+          print_list_type(node)
+        when Nodes::NonNullType
+          print_non_null_type(node)
+        when Nodes::OperationDefinition
+          print_operation_definition(node, indent: indent)
+        when Nodes::TypeName
+          print_type_name(node)
+        when Nodes::VariableDefinition
+          print_variable_definition(node)
+        when Nodes::VariableIdentifier
+          print_variable_identifier(node)
+        when Nodes::SchemaDefinition
+          print_schema_definition(node)
+        when Nodes::ScalarTypeDefinition
+          print_scalar_type_definition(node)
+        when Nodes::ObjectTypeDefinition
+          print_object_type_definition(node)
+        when Nodes::InputValueDefinition
+          print_input_value_definition(node)
+        when Nodes::FieldDefinition
+          print_field_definition(node)
+        when Nodes::InterfaceTypeDefinition
+          print_interface_type_definition(node)
+        when Nodes::UnionTypeDefinition
+          print_union_type_definition(node)
+        when Nodes::EnumTypeDefinition
+          print_enum_type_definition(node)
+        when Nodes::EnumValueDefinition
+          print_enum_value_definition(node)
+        when Nodes::InputObjectTypeDefinition
+          print_input_object_type_definition(node)
+        when Nodes::DirectiveDefinition
+          print_directive_definition(node)
+        when FalseClass, Float, Integer, NilClass, String, TrueClass, Symbol
+          GraphQL::Language.serialize(node)
+        when Array
+          "[#{node.map { |v| print_node(v) }.join(", ")}]".dup
+        when Hash
+          "{#{node.map { |k, v| "#{k}: #{print_node(v)}" }.join(", ")}}".dup
+        else
+          GraphQL::Language.serialize(node.to_s)
+        end
+      end
+
+      private
+
+      attr_reader :node
+    end
+  end
+end

data/lib/graphql/language/token.rb

@@ -5,23 +5,30 @@ module GraphQL
     # Contains type, value and position data.
     class Token
       # @return [Symbol] The kind of token this is
-      attr_reader :name, :prev_token, :line
+      attr_reader :name
+      # @return [String] The text of this token
+      attr_reader :value
+      attr_reader :prev_token, :line, :col
 
       def initialize(value:, name:, line:, col:, prev_token:)
         @name = name
-        @value = value
+        @value = value.freeze
         @line = line
         @col = col
         @prev_token = prev_token
       end
 
-      def to_s; @value; end
+      alias to_s value
       def to_i; @value.to_i; end
       def to_f; @value.to_f; end
 
       def line_and_column
         [@line, @col]
       end
+
+      def inspect
+        "(#{@name} #{@value.inspect} [#{@line}:#{@col}])"
+      end
     end
   end
 end

data/lib/graphql/language.rb

@@ -1,5 +1,8 @@
 # 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/non_null_type.rb

@@ -33,7 +33,7 @@ module GraphQL
   #
   class NonNullType < GraphQL::BaseType
     include GraphQL::BaseType::ModifiesAnotherType
-    extend GraphQL::Delegate
+    extend Forwardable
 
     attr_reader :of_type
     def initialize(of_type:)

data/lib/graphql/object_type.rb

@@ -32,7 +32,7 @@ module GraphQL
     #   @return [Hash<String => GraphQL::Field>] Map String fieldnames to their {GraphQL::Field} implementations
 
     # @!attribute mutation
-    #   @return [GraphQL::Relay::Mutation, nil] The mutation this field was derived from, if it was derived from a mutation
+    #   @return [GraphQL::Relay::Mutation, nil] The mutation this object type was derived from, if it is an auto-generated payload type.
 
     def initialize
       super
@@ -102,11 +102,6 @@ module GraphQL
       dirty_ifaces.concat(interfaces)
     end
 
-    def name=(name)
-      GraphQL::NameValidator.validate!(name)
-      @name = name
-    end
-
     protected
 
     attr_reader :dirty_interfaces, :dirty_inherited_interfaces

data/lib/graphql/query/arguments.rb

@@ -5,44 +5,44 @@ module GraphQL
     #
     # {Arguments} recursively wraps the input in {Arguments} instances.
     class Arguments
-      extend GraphQL::Delegate
+      extend Forwardable
 
       def self.construct_arguments_class(argument_owner)
         argument_definitions = argument_owner.arguments
         argument_owner.arguments_class = Class.new(self) do
           self.argument_definitions = argument_definitions
 
-          def initialize(values)
-            super(values, argument_definitions: self.class.argument_definitions)
-          end
-
           argument_definitions.each do |_arg_name, arg_definition|
             expose_as = arg_definition.expose_as.to_s
-
-            # Don't define a helper method if it would override something.
-            if instance_methods.include?(expose_as)
-              warn(
-                "Unable to define a helper for argument with name '#{expose_as}' "\
-                "as this is a reserved name. If you're using an argument such as "\
-                "`argument #{expose_as}`, consider renaming this argument.`"
-              )
-              next
-            end
-
-            define_method(expose_as) do
-              self[expose_as]
+            expose_as_underscored = GraphQL::Schema::Member::BuildType.underscore(expose_as)
+            method_names = [expose_as, expose_as_underscored].uniq
+            method_names.each do |method_name|
+              # Don't define a helper method if it would override something.
+              if instance_methods.include?(method_name)
+                warn(
+                  "Unable to define a helper for argument with name '#{method_name}' "\
+                  "as this is a reserved name. If you're using an argument such as "\
+                  "`argument #{method_name}`, consider renaming this argument.`"
+                )
+              else
+                define_method(method_name) do
+                  # Always use `expose_as` here, since #[] doesn't accept underscored names
+                  self[expose_as]
+                end
+              end
             end
           end
         end
       end
 
-      def initialize(values, argument_definitions:)
+      def initialize(values, context:, defaults_used:)
         @argument_values = values.inject({}) do |memo, (inner_key, inner_value)|
-          arg_defn = argument_definitions[inner_key.to_s]
-
-          arg_value = wrap_value(inner_value, arg_defn.type)
+          arg_name = inner_key.to_s
+          arg_defn = self.class.argument_definitions[arg_name]
+          arg_default_used = defaults_used.include?(arg_name)
+          arg_value = wrap_value(inner_value, arg_defn.type, context)
           string_key = arg_defn.expose_as
-          memo[string_key] = ArgumentValue.new(string_key, arg_value, arg_defn)
+          memo[string_key] = ArgumentValue.new(string_key, arg_value, arg_defn, arg_default_used)
           memo
         end
       end
@@ -61,6 +61,13 @@ module GraphQL
         @argument_values.key?(key_s)
       end
 
+      # @param key [String, Symbol] name of value to access
+      # @return [Boolean] true if the argument default was passed as the argument value to the resolver
+      def default_used?(key)
+        key_s = key.is_a?(String) ? key : key.to_s
+        @argument_values.fetch(key_s, NULL_ARGUMENT_VALUE).default_used?
+      end
+
       # Get the hash of all values, with stringified keys
       # @return [Hash] the stringified hash
       def to_h
@@ -74,7 +81,7 @@ module GraphQL
         end
       end
 
-      def_delegators :to_h, :keys, :values, :each
+      def_delegators :to_h, :keys, :values, :each, :any?
 
       # Access each key, value and type for the arguments in this set.
       # @yield [argument_value] The {ArgumentValue} for each argument
@@ -85,37 +92,61 @@ module GraphQL
         end
       end
 
-      NO_ARGS = self.new({}, argument_definitions: [])
-
       class << self
         attr_accessor :argument_definitions
       end
 
+      NoArguments = Class.new(self) do
+        self.argument_definitions = []
+      end
+
+      NO_ARGS = NoArguments.new({}, context: nil, defaults_used: Set.new)
+
+      # Convert this instance into valid Ruby keyword arguments
+      # @return [{Symbol=>Object}]
+      def to_kwargs
+        ruby_kwargs = {}
+
+        keys.each do |key|
+          ruby_kwargs[Schema::Member::BuildType.underscore(key).to_sym] = self[key]
+        end
+
+        ruby_kwargs
+      end
+
       private
 
       class ArgumentValue
         attr_reader :key, :value, :definition
-        def initialize(key, value, definition)
+        attr_writer :default_used
+
+        def initialize(key, value, definition, default_used)
           @key = key
           @value = value
           @definition = definition
+          @default_used = default_used
+        end
+
+        # @return [Boolean] true if the argument default was passed as the argument value to the resolver
+        def default_used?
+          @default_used
         end
       end
 
-      NULL_ARGUMENT_VALUE = ArgumentValue.new(nil, nil, nil)
+      NULL_ARGUMENT_VALUE = ArgumentValue.new(nil, nil, nil, nil)
 
-      def wrap_value(value, arg_defn_type)
+      def wrap_value(value, arg_defn_type, context)
         if value.nil?
           nil
         else
           case arg_defn_type
           when GraphQL::ListType
-            value.map { |item| wrap_value(item, arg_defn_type.of_type) }
+            value.map { |item| wrap_value(item, arg_defn_type.of_type, context) }
           when GraphQL::NonNullType
-            wrap_value(value, arg_defn_type.of_type)
+            wrap_value(value, arg_defn_type.of_type, context)
           when GraphQL::InputObjectType
             if value.is_a?(Hash)
-              arg_defn_type.arguments_class.new(value)
+              arg_defn_type.arguments_class.new(value, context: context, defaults_used: Set.new)
             else
               value
             end