graphql 1.7.6 → 1.8.0

data/lib/graphql/query/context.rb

@@ -70,10 +70,36 @@ module GraphQL
         def backtrace
           GraphQL::Backtrace.new(self)
         end
+
+        def execution_errors
+          @execution_errors ||= ExecutionErrors.new(self)
+        end
+      end
+
+      class ExecutionErrors
+        def initialize(ctx)
+          @context = ctx
+        end
+
+        def add(err_or_msg)
+          err = case err_or_msg
+          when String
+            GraphQL::ExecutionError.new(err_or_msg)
+          when GraphQL::ExecutionError
+            err_or_msg
+          else
+            raise ArgumentError, "expected String or GraphQL::ExecutionError, not #{err_or_msg.class} (#{err_or_msg.inspect})"
+          end
+          # This will assign ast_node and path
+          @context.add_error(err)
+        end
+
+        alias :>> :add
+        alias :push :add
       end
 
       include SharedMethods
-      extend GraphQL::Delegate
+      extend Forwardable
 
       attr_reader :execution_strategy
       # `strategy` is required by GraphQL::Batch
@@ -129,6 +155,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:`
@@ -162,7 +189,7 @@ module GraphQL
       class FieldResolutionContext
         include SharedMethods
         include Tracing::Traceable
-        extend GraphQL::Delegate
+        extend Forwardable
 
         attr_reader :irep_node, :field, :parent_type, :query, :schema, :parent, :key, :type
         alias :selection :irep_node
@@ -267,3 +294,6 @@ module GraphQL
     end
   end
 end
+
+
+GraphQL::Schema::Context = GraphQL::Query::Context

data/lib/graphql/query/literal_input.rb

@@ -49,6 +49,8 @@ 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
@@ -93,6 +95,7 @@ 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)
@@ -105,7 +108,7 @@ module GraphQL
           end
         end
 
-        argument_owner.arguments_class.new(values_hash)
+        argument_owner.arguments_class.new(values_hash, context: context, defaults_used: defaults_used)
       end
     end
   end

data/lib/graphql/query/null_context.rb

@@ -22,7 +22,7 @@ module GraphQL
       end
 
       class << self
-        extend GraphQL::Delegate
+        extend Forwardable
 
         def instance
           @instance = self.new

data/lib/graphql/query/result.rb

@@ -6,7 +6,7 @@ module GraphQL
     # It provides the requested data and
     # access to the {Query} and {Query::Context}.
     class Result
-      extend GraphQL::Delegate
+      extend Forwardable
 
       def initialize(query:, values:)
         @query = query

data/lib/graphql/query/variables.rb

@@ -3,7 +3,7 @@ module GraphQL
   class Query
     # Read-only access to query variables, applying default values if needed.
     class Variables
-      extend GraphQL::Delegate
+      extend Forwardable
 
       # @return [Array<GraphQL::Query::VariableValidationError>]  Any errors encountered when parsing the provided variables and literal values
       attr_reader :errors
@@ -13,7 +13,8 @@ module GraphQL
       def initialize(ctx, ast_variables, provided_variables)
         schema = ctx.schema
         @context = ctx
-        @provided_variables = provided_variables
+
+        @provided_variables = deep_stringify(provided_variables)
         @errors = []
         @storage = ast_variables.each_with_object({}) do |ast_variable, memo|
           # Find the right value for this variable:
@@ -27,7 +28,7 @@ module GraphQL
             variable_name = ast_variable.name
             default_value = ast_variable.default_value
             provided_value = @provided_variables[variable_name]
-            value_was_provided = @provided_variables.key?(variable_name)
+            value_was_provided =  @provided_variables.key?(variable_name)
 
             validation_result = variable_type.validate_input(provided_value, ctx)
             if !validation_result.valid?
@@ -45,6 +46,23 @@ module GraphQL
       end
 
       def_delegators :@storage, :length, :key?, :[], :fetch, :to_h
+
+      private
+
+      def deep_stringify(val)
+        case val
+        when Array
+          val.map { |v| deep_stringify(v) }
+        when Hash
+          new_val = {}
+          val.each do |k, v|
+            new_val[k.to_s] = deep_stringify(v)
+          end
+          new_val
+        else
+          val
+        end
+      end
     end
   end
 end

data/lib/graphql/query.rb

@@ -16,7 +16,7 @@ module GraphQL
   # A combination of query string and {Schema} instance which can be reduced to a {#result}.
   class Query
     include Tracing::Traceable
-    extend GraphQL::Delegate
+    extend Forwardable
 
     class OperationNameMissingError < GraphQL::ExecutionError
       def initialize(name)
@@ -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,6 +47,10 @@ 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
@@ -72,7 +79,7 @@ module GraphQL
     def initialize(schema, query_string = nil, query: nil, document: nil, context: nil, variables: {}, validate: true, subscription_topic: nil, operation_name: nil, root_value: nil, max_depth: nil, max_complexity: nil, except: nil, only: nil)
       @schema = schema
       @filter = schema.default_filter.merge(except: except, only: only)
-      @context = Context.new(query: self, object: root_value, values: context)
+      @context = schema.context_class.new(query: self, object: root_value, values: context)
       @subscription_topic = subscription_topic
       @root_value = root_value
       @fragments = nil
@@ -153,7 +160,7 @@ module GraphQL
     def result
       if !@executed
         with_prepared_ast {
-          Execution::Multiplex.run_queries(@schema, [self])
+          Execution::Multiplex.run_queries(@schema, [self], context: @context)
         }
       end
       @result ||= Query::Result.new(query: self, values: @result_values)
@@ -190,8 +197,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
 
@@ -234,6 +244,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/railtie.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+
+module GraphQL
+  class Railtie < Rails::Railtie
+    rake_tasks do
+      # Defer this so that you only need the `parser` gem when you _run_ the upgrader
+      def load_upgraders
+        require_relative './upgrader/member'
+        require_relative './upgrader/schema'
+      end
+
+      namespace :graphql do
+        task :upgrade, [:dir] do |t, args|
+          unless (dir = args[:dir])
+            fail 'You have to give me a directory where your GraphQL schema and types live. ' \
+             'For example: `bin/rake graphql:upgrade[app/graphql/**/*]`'
+          end
+
+          Dir[dir].each do |file|
+            # Members (types, interfaces, etc.)
+            if file =~ /.*_(type|interface|enum|union|)\.rb$/
+              Rake::Task["graphql:upgrade:member"].execute(Struct.new(:member_file).new(file))
+            end
+          end
+
+          puts "Upgrade complete! Note that this is a best-effort approach, and may very well contain some bugs."
+          puts "Don't forget to create the base objects. For example, you could run:"
+          puts "\tbin/rake graphql:upgrade:create_base_objects[app/graphql]"
+        end
+
+        namespace :upgrade do
+          task :create_base_objects, [:base_dir] do |t, args|
+            unless (base_dir = args[:base_dir])
+              fail 'You have to give me a directory where your GraphQL types live. ' \
+                   'For example: `bin/rake graphql:upgrade:create_base_objects[app/graphql]`'
+            end
+
+            destination_file = File.join(base_dir, "types", "base_scalar.rb")
+            unless File.exists?(destination_file)
+              FileUtils.mkdir_p(File.dirname(destination_file))
+              File.open(destination_file, 'w') do |f|
+                f.write "class Types::BaseScalar < GraphQL::Schema::Scalar\nend"
+              end
+            end
+
+            destination_file = File.join(base_dir, "types", "base_input_object.rb")
+            unless File.exists?(destination_file)
+              FileUtils.mkdir_p(File.dirname(destination_file))
+              File.open(destination_file, 'w') do |f|
+                f.write "class Types::BaseInputObject < GraphQL::Schema::InputObject\nend"
+              end
+            end
+
+            destination_file = File.join(base_dir, "types", "base_enum.rb")
+            unless File.exists?(destination_file)
+              FileUtils.mkdir_p(File.dirname(destination_file))
+              File.open(destination_file, 'w') do |f|
+                f.write "class Types::BaseEnum < GraphQL::Schema::Enum\nend"
+              end
+            end
+
+            destination_file = File.join(base_dir, "types", "base_union.rb")
+            unless File.exists?(destination_file)
+              FileUtils.mkdir_p(File.dirname(destination_file))
+              File.open(destination_file, 'w') do |f|
+                f.write "class Types::BaseUnion < GraphQL::Schema::Union\nend"
+              end
+            end
+
+            destination_file = File.join(base_dir, "types", "base_interface.rb")
+            unless File.exists?(destination_file)
+              FileUtils.mkdir_p(File.dirname(destination_file))
+              File.open(destination_file, 'w') do |f|
+                f.write "module Types::BaseInterface\n  include GraphQL::Schema::Interface\nend"
+              end
+            end
+
+            destination_file = File.join(base_dir, "types", "base_object.rb")
+            unless File.exists?(destination_file)
+              File.open(destination_file, 'w') do |f|
+                f.write "class Types::BaseObject < GraphQL::Schema::Object\nend"
+              end
+            end
+          end
+
+          task :schema, [:schema_file] do |t, args|
+            schema_file = args.schema_file
+            load_upgraders
+            upgrader = GraphQL::Upgrader::Schema.new File.read(schema_file)
+
+            puts "- Transforming schema #{schema_file}"
+            File.open(schema_file, 'w') { |f| f.write upgrader.upgrade }
+          end
+
+          task :member, [:member_file] do |t, args|
+            member_file = args.member_file
+            load_upgraders
+            upgrader = GraphQL::Upgrader::Member.new File.read(member_file)
+            next unless upgrader.upgradeable?
+
+            puts "- Transforming member #{member_file}"
+            File.open(member_file, 'w') { |f| f.write upgrader.upgrade }
+          end
+        end
+      end
+    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/connection_type.rb

@@ -13,15 +13,17 @@ module GraphQL
       self.bidirectional_pagination = false
 
       # Create a connection which exposes edges of this type
-      def self.create_type(wrapped_type, edge_type: wrapped_type.edge_type, edge_class: GraphQL::Relay::Edge, nodes_field: ConnectionType.default_nodes_field, &block)
+      def self.create_type(wrapped_type, edge_type: nil, edge_class: GraphQL::Relay::Edge, nodes_field: ConnectionType.default_nodes_field, &block)
         custom_edge_class = edge_class
 
         # Any call that would trigger `wrapped_type.ensure_defined`
         # must be inside this lazy block, otherwise we get weird
         # cyclical dependency errors :S
         ObjectType.define do
-          name("#{wrapped_type.name}Connection")
-          description("The connection type for #{wrapped_type.name}.")
+          type_name = wrapped_type.is_a?(GraphQL::BaseType) ? wrapped_type.name : wrapped_type.graphql_name
+          edge_type ||= wrapped_type.edge_type
+          name("#{type_name}Connection")
+          description("The connection type for #{type_name}.")
           field :edges, types[edge_type], "A list of edges.", edge_class: custom_edge_class, property: :edge_nodes
 
           if nodes_field

data/lib/graphql/relay/edge_type.rb

@@ -4,7 +4,8 @@ module GraphQL
     module EdgeType
       def self.create_type(wrapped_type, name: nil, &block)
         GraphQL::ObjectType.define do
-          name("#{wrapped_type.name}Edge")
+          type_name = wrapped_type.is_a?(GraphQL::BaseType) ? wrapped_type.name : wrapped_type.graphql_name
+          name("#{type_name}Edge")
           description "An edge in a connection."
           field :node, wrapped_type, "The item at the end of the edge."
           field :cursor, !types.String, "A cursor for use in pagination."

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+module GraphQL
+  module Relay
+    # A connection implementation to expose MongoDB collection objects.
+    # It works for:
+    # - `Mongoid::Criteria`
+    class MongoRelationConnection < RelationConnection
+      private
+
+      def relation_offset(relation)
+        relation.options.skip
+      end
+
+      def relation_limit(relation)
+        relation.options.limit
+      end
+
+      def relation_count(relation)
+        # Must perform query (hence #to_a) to count results https://jira.mongodb.org/browse/MONGOID-2325
+        relation.to_a.count
+      end
+
+      def limit_nodes(sliced_nodes, limit)
+        if limit == 0
+          if sliced_nodes.respond_to?(:none) # added in Mongoid 4.0
+            sliced_nodes.without_options.none
+          else
+            sliced_nodes.where(id: nil) # trying to simulate #none for 3.1.7
+          end
+        else
+          sliced_nodes.limit(limit)
+        end
+      end
+    end
+
+    if defined?(Mongoid::Criteria)
+      BaseConnection.register_connection_implementation(Mongoid::Criteria, MongoRelationConnection)
+    end
+  end
+end

data/lib/graphql/relay/mutation/instrumentation.rb

@@ -10,7 +10,7 @@ module GraphQL
         # By using an instrumention, we can apply our wrapper _last_,
         # giving users access to the original resolve function in earlier instrumentation.
         def self.instrument(type, field)
-          if field.mutation
+          if field.mutation.is_a?(GraphQL::Relay::Mutation) || (field.mutation.is_a?(Class) && field.mutation < GraphQL::Schema::RelayClassicMutation)
             new_resolve = Mutation::Resolve.new(field.mutation, field.resolve_proc)
             new_lazy_resolve = Mutation::Resolve.new(field.mutation, field.lazy_resolve_proc)
             field.redefine(resolve: new_resolve, lazy_resolve: new_lazy_resolve)

data/lib/graphql/relay/mutation/resolve.rb

@@ -10,7 +10,8 @@ module GraphQL
         def initialize(mutation, resolve)
           @mutation = mutation
           @resolve = resolve
-          @wrap_result = mutation.has_generated_return_type?
+          @wrap_result = mutation.is_a?(GraphQL::Relay::Mutation) && mutation.has_generated_return_type?
+          @class_based = mutation.is_a?(Class)
         end
 
         def call(obj, args, ctx)
@@ -44,6 +45,9 @@ module GraphQL
             end
 
             @mutation.result_class.new(client_mutation_id: args[:input][:clientMutationId], result: mutation_result)
+          elsif @class_based
+            mutation_result[:client_mutation_id] = args[:input][:client_mutation_id]
+            mutation_result
           else
             mutation_result
           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_array.index(item)
+        item_index = paged_nodes.index(item)
         if item_index.nil?
           raise("Can't generate cursor, item not found in connection: #{item}")
         else
-          offset = item_index + 1 + ((relation_offset(paged_nodes) || 0) - (relation_offset(sliced_nodes) || 0))
+          offset = item_index + 1 + ((paged_nodes_offset || 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,6 +64,7 @@ module GraphQL
       private
 
       # apply first / last limit results
+      # @return [Array]
       def paged_nodes
         return @paged_nodes if defined? @paged_nodes
 
@@ -94,7 +95,14 @@ module GraphQL
           end
         end
 
-        @paged_nodes = items
+        # 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
       end
 
       def relation_offset(relation)
@@ -166,19 +174,6 @@ 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)

data/lib/graphql/relay/type_extensions.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+module GraphQL
+  module Relay
+    # Mixin for Relay-related methods in type objects
+    # (used by BaseType and Schema::Member).
+    module TypeExtensions
+      # @return [GraphQL::ObjectType] The default connection type for this object type
+      def connection_type
+        @connection_type ||= define_connection
+      end
+
+      # Define a custom connection type for this object type
+      # @return [GraphQL::ObjectType]
+      def define_connection(**kwargs, &block)
+        GraphQL::Relay::ConnectionType.create_type(self, **kwargs, &block)
+      end
+
+      # @return [GraphQL::ObjectType] The default edge type for this object type
+      def edge_type
+        @edge_type ||= define_edge
+      end
+
+      # Define a custom edge type for this object type
+      # @return [GraphQL::ObjectType]
+      def define_edge(**kwargs, &block)
+        GraphQL::Relay::EdgeType.create_type(self, **kwargs, &block)
+      end
+    end
+  end
+end

data/lib/graphql/relay.rb

@@ -9,9 +9,11 @@ require 'graphql/relay/base_connection'
 require 'graphql/relay/array_connection'
 require 'graphql/relay/range_add'
 require 'graphql/relay/relation_connection'
+require 'graphql/relay/mongo_relation_connection'
 require 'graphql/relay/global_id_resolve'
 require 'graphql/relay/mutation'
 require 'graphql/relay/node'
 require 'graphql/relay/connection_instrumentation'
 require 'graphql/relay/connection_resolve'
 require 'graphql/relay/connection_type'
+require 'graphql/relay/type_extensions'

data/lib/graphql/scalar_type.rb

@@ -56,7 +56,7 @@ module GraphQL
   # This will result in the message of the `GraphQL::CoercionError` being used in the error response:
   #
   # @example custom error response
-  # {"message"=>"cannot coerce `"2"` to Float", "locations"=>[{"line"=>3, "column"=>9}], "fields"=>["arg"]}
+  #   {"message"=>"cannot coerce `"2"` to Float", "locations"=>[{"line"=>3, "column"=>9}], "fields"=>["arg"]}
   #
   class ScalarType < GraphQL::BaseType
     accepts_definitions :coerce, :coerce_input, :coerce_result
@@ -109,7 +109,19 @@ module GraphQL
     end
 
     def coerce_non_null_input(value, ctx)
-      @coerce_input_proc.call(value, ctx)
+      @coerce_input_proc.call(raw_coercion_input(value), ctx)
+    end
+
+    def raw_coercion_input(value)
+      if value.is_a?(GraphQL::Language::Nodes::InputObject)
+        value.to_h
+      elsif value.is_a?(Array)
+        value.map { |element| raw_coercion_input(element) }
+      elsif value.is_a?(GraphQL::Language::Nodes::Enum)
+        value.name
+      else
+        value
+      end
     end
 
     def validate_non_null_input(value, ctx)