graphql 1.7.14 → 1.8.0.pre1

data/lib/graphql/language/parser.y

@@ -82,7 +82,8 @@ rule
     | EQUALS literal_value  { return val[1] }
 
   selection_set:
-      LCURLY selection_list RCURLY { return val[1] }
+      LCURLY RCURLY                { return [] }
+    | LCURLY selection_list RCURLY { return val[1] }
 
   selection_set_opt:
       /* none */    { return [] }
@@ -152,8 +153,12 @@ 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]), position_source: val[0]) }
+    enum_name directives_list_opt { return make_node(:EnumValueDefinition, name: val[0], directives: val[1], description: get_description(val[0])) }
 
   enum_value_definitions:
       enum_value_definition                        { return [val[0]] }
@@ -302,21 +307,11 @@ rule
 
   implements_opt:
       /* none */ { return [] }
-    | 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]) }
+    | IMPLEMENTS name_list { return 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]), position_source: val[0])
+        return make_node(:InputValueDefinition, name: val[0], type: val[2], default_value: val[3], directives: val[4], description: get_description(val[0]))
       }
 
   input_value_definition_list:
@@ -329,12 +324,11 @@ 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]), position_source: val[0])
+        return make_node(:FieldDefinition, name: val[0], arguments: val[1], type: val[3], directives: val[4], description: get_description(val[0]))
       }
 
   field_definition_list:
-    /* none */ { return [] }
-    | field_definition                       { return [val[0]] }
+      field_definition                       { return [val[0]] }
     | field_definition_list field_definition { val[0] << val[1] }
 
   interface_type_definition:

data/lib/graphql/language/token.rb

@@ -5,30 +5,23 @@ module GraphQL
     # Contains type, value and position data.
     class Token
       # @return [Symbol] The kind of token this is
-      attr_reader :name
-      # @return [String] The text of this token
-      attr_reader :value
-      attr_reader :prev_token, :line, :col
+      attr_reader :name, :prev_token, :line
 
       def initialize(value:, name:, line:, col:, prev_token:)
         @name = name
-        @value = value.freeze
+        @value = value
         @line = line
         @col = col
         @prev_token = prev_token
       end
 
-      alias to_s value
+      def to_s; @value; end
       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/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 object type was derived from, if it is an auto-generated payload type.
+    #   @return [GraphQL::Relay::Mutation, nil] The mutation this field was derived from, if it was derived from a mutation
 
     def initialize
       super
@@ -102,6 +102,11 @@ 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.rb

@@ -29,7 +29,10 @@ module GraphQL
       end
     end
 
-    attr_reader :schema, :context, :root_value, :warden, :provided_variables
+    attr_reader :schema, :context, :warden, :provided_variables
+
+    # The value for root types
+    attr_accessor :root_value
 
     # @return [nil, String] The operation name provided by client or the one inferred from the document. Used to determine which operation to run.
     attr_accessor :operation_name
@@ -44,10 +47,6 @@ module GraphQL
       with_prepared_ast { @document }
     end
 
-    def inspect
-      "query ..."
-    end
-
     # @return [String, nil] The name of the operation to run (may be inferred)
     def selected_operation_name
       return nil unless selected_operation
@@ -157,7 +156,7 @@ module GraphQL
     def result
       if !@executed
         with_prepared_ast {
-          Execution::Multiplex.run_queries(@schema, [self], context: @context)
+          Execution::Multiplex.run_queries(@schema, [self])
         }
       end
       @result ||= Query::Result.new(query: self, values: @result_values)
@@ -194,8 +193,11 @@ module GraphQL
 
     def irep_selection
       @selection ||= begin
-        return nil unless selected_operation
-        internal_representation.operation_definitions[selected_operation.name]
+        if selected_operation && internal_representation
+          internal_representation.operation_definitions[selected_operation.name]
+        else
+          nil
+        end
       end
     end
 
@@ -238,6 +240,9 @@ module GraphQL
         value = abstract_type
         abstract_type = nil
       end
+      if value.is_a?(GraphQL::Schema::Object)
+        value = value.object
+      end
       @resolved_types_cache[abstract_type][value]
     end
 

data/lib/graphql/query/arguments.rb

@@ -12,40 +12,36 @@ module GraphQL
         argument_owner.arguments_class = Class.new(self) do
           self.argument_definitions = argument_definitions
 
-          def initialize(values, defaults_used)
-            super(values, argument_definitions: self.class.argument_definitions, defaults_used: defaults_used)
-          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:, defaults_used:)
+      def initialize(values, context:)
         @argument_values = values.inject({}) do |memo, (inner_key, inner_value)|
-          arg_name = inner_key.to_s
+          arg_defn = self.class.argument_definitions[inner_key.to_s]
 
-          arg_defn = argument_definitions[arg_name]
-          arg_default_used = defaults_used.include?(arg_name)
-
-          arg_value = wrap_value(inner_value, arg_defn.type)
+          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, arg_default_used)
+          memo[string_key] = ArgumentValue.new(string_key, arg_value, arg_defn)
           memo
         end
       end
@@ -64,13 +60,6 @@ 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
@@ -84,7 +73,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
@@ -95,45 +84,41 @@ module GraphQL
         end
       end
 
-      NO_ARGS = self.new({}, argument_definitions: [], defaults_used: Set.new)
-
       class << self
         attr_accessor :argument_definitions
       end
 
+      NoArguments = Class.new(self) do
+        self.argument_definitions = []
+      end
+
+      NO_ARGS = NoArguments.new({}, context: nil)
+
       private
 
       class ArgumentValue
         attr_reader :key, :value, :definition
-        attr_writer :default_used
-
-        def initialize(key, value, definition, default_used)
+        def initialize(key, value, definition)
           @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, nil)
+      NULL_ARGUMENT_VALUE = ArgumentValue.new(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, Set.new)
+              arg_defn_type.arguments_class.new(value, context: context)
             else
               value
             end

data/lib/graphql/query/context.rb

@@ -129,6 +129,7 @@ module GraphQL
       attr_writer :value
 
       def_delegators :@provided_values, :[], :[]=, :to_h, :key?, :fetch
+      def_delegators :@query, :trace
 
       # @!method [](key)
       #   Lookup `key` from the hash passed to {Schema#execute} as `context:`

data/lib/graphql/query/literal_input.rb

@@ -49,8 +49,6 @@ module GraphQL
       def self.from_arguments(ast_arguments, argument_owner, variables)
         context = variables ? variables.context : nil
         values_hash = {}
-        defaults_used = Set.new
-
         indexed_arguments = case ast_arguments
         when Hash
           ast_arguments
@@ -95,7 +93,6 @@ module GraphQL
           # then add the default value.
           if arg_defn.default_value? && !values_hash.key?(arg_name)
             value = arg_defn.default_value
-            defaults_used << arg_name
             # `context` isn't present when pre-calculating defaults
             if context
               value = arg_defn.prepare(value, context)
@@ -108,7 +105,7 @@ module GraphQL
           end
         end
 
-        argument_owner.arguments_class.new(values_hash, defaults_used)
+        argument_owner.arguments_class.new(values_hash, context: context)
       end
     end
   end

data/lib/graphql/relay/connection_resolve.rb

@@ -41,6 +41,9 @@ module GraphQL
           ctx.add_error(nodes)
           nil
         else
+          if parent.is_a?(GraphQL::Schema::Object)
+            parent = parent.object
+          end
           connection_class = GraphQL::Relay::BaseConnection.connection_for_nodes(nodes)
           connection_class.new(nodes, args, field: @field, max_page_size: @max_page_size, parent: parent, context: ctx)
         end

data/lib/graphql/relay/global_id_resolve.rb

@@ -7,7 +7,11 @@ module GraphQL
       end
 
       def call(obj, args, ctx)
-        ctx.query.schema.id_from_object(obj, @type, ctx)
+        if obj.is_a?(GraphQL::Schema::Object)
+          obj = obj.object
+        end
+        type = @type.respond_to?(:graphql_definition) ? @type.graphql_definition : @type
+        ctx.query.schema.id_from_object(obj, type, ctx)
       end
     end
   end

data/lib/graphql/relay/relation_connection.rb

@@ -7,11 +7,11 @@ module GraphQL
     # - `Sequel::Dataset`
     class RelationConnection < BaseConnection
       def cursor_from_node(item)
-        item_index = paged_nodes.index(item)
+        item_index = paged_nodes_array.index(item)
         if item_index.nil?
           raise("Can't generate cursor, item not found in connection: #{item}")
         else
-          offset = item_index + 1 + ((paged_nodes_offset || 0) - (relation_offset(sliced_nodes) || 0))
+          offset = item_index + 1 + ((relation_offset(paged_nodes) || 0) - (relation_offset(sliced_nodes) || 0))
 
           if after
             offset += offset_from_cursor(after)
@@ -25,9 +25,9 @@ module GraphQL
 
       def has_next_page
         if first
-          paged_nodes.length >= first && sliced_nodes_count > first
+          paged_nodes_length >= first && sliced_nodes_count > first
         elsif GraphQL::Relay::ConnectionType.bidirectional_pagination && last
-          sliced_nodes_count >= last
+          sliced_nodes_count > last
         else
           false
         end
@@ -35,7 +35,7 @@ module GraphQL
 
       def has_previous_page
         if last
-          paged_nodes.length >= last && sliced_nodes_count > last
+          paged_nodes_length >= last && sliced_nodes_count > last
         elsif GraphQL::Relay::ConnectionType.bidirectional_pagination && after
           # We've already paginated through the collection a bit,
           # there are nodes behind us
@@ -64,7 +64,6 @@ module GraphQL
       private
 
       # apply first / last limit results
-      # @return [Array]
       def paged_nodes
         return @paged_nodes if defined? @paged_nodes
 
@@ -95,14 +94,7 @@ module GraphQL
           end
         end
 
-        # Store this here so we can convert the relation to an Array
-        # (this avoids an extra DB call on Sequel)
-        @paged_nodes_offset = relation_offset(items)
-        @paged_nodes = items.to_a
-      end
-
-      def paged_nodes_offset
-        paged_nodes && @paged_nodes_offset
+        @paged_nodes = items
       end
 
       def relation_offset(relation)
@@ -174,6 +166,19 @@ module GraphQL
       def offset_from_cursor(cursor)
         decode(cursor).to_i
       end
+
+      def paged_nodes_array
+        return @paged_nodes_array if defined?(@paged_nodes_array)
+        @paged_nodes_array = paged_nodes.to_a
+      end
+
+      def paged_nodes_length
+        if paged_nodes.respond_to?(:length)
+          paged_nodes.length
+        else
+          paged_nodes_array.length
+        end
+      end
     end
 
     if defined?(ActiveRecord::Relation)