graphql 1.5.15 → 1.6.0

data/lib/graphql/relay/base_connection.rb

@@ -26,14 +26,16 @@ module GraphQL
         # @return [subclass of BaseConnection] a connection Class for wrapping `nodes`
         def connection_for_nodes(nodes)
           # Check for class _names_ because classes can be redefined in Rails development
-          nodes.class.ancestors.each do |ancestor|
-            conn_impl = CONNECTION_IMPLEMENTATIONS[ancestor.name]
-            if conn_impl
-              return conn_impl
-            end
+          ancestor_names = nodes.class.ancestors.map(&:name)
+          implementation_class_name = ancestor_names.find do |ancestor_class_name|
+            CONNECTION_IMPLEMENTATIONS.include? ancestor_class_name
+          end
+
+          if implementation_class_name.nil?
+            raise("No connection implementation to wrap #{nodes.class} (#{nodes})")
+          else
+            CONNECTION_IMPLEMENTATIONS[implementation_class_name]
           end
-          # Should have found a connection during the loop:
-          raise("No connection implementation to wrap #{nodes.class} (#{nodes})")
         end
 
         # Add `connection_class` as the connection wrapper for `nodes_class`

data/lib/graphql/relay/mutation.rb

@@ -184,17 +184,6 @@ module GraphQL
       def result_class
         @result_class ||= Result.define_subclass(self)
       end
-
-      private
-
-      def get_arity(callable)
-        case callable
-        when Proc
-          callable.arity
-        else
-          callable.method(:call).arity
-        end
-      end
     end
   end
 end

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

@@ -11,8 +11,8 @@ module GraphQL
         # giving users access to the original resolve function in earlier instrumentation.
         def self.instrument(type, field)
           if field.mutation
-            new_resolve = Mutation::Resolve.new(field.mutation, field.resolve_proc, eager: true)
-            new_lazy_resolve = Mutation::Resolve.new(field.mutation, field.lazy_resolve_proc, eager: false)
+            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)
           else
             field

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

@@ -7,38 +7,35 @@ module GraphQL
       # Also, pass the `clientMutationId` to that result object.
       # @api private
       class Resolve
-        def initialize(mutation, resolve, eager:)
+        def initialize(mutation, resolve)
           @mutation = mutation
           @resolve = resolve
           @wrap_result = mutation.has_generated_return_type?
-          @eager = eager
         end
 
         def call(obj, args, ctx)
-          error_raised = false
-          begin
-            mutation_result = @resolve.call(obj, args[:input], ctx)
+          mutation_result = begin
+            @resolve.call(obj, args[:input], ctx)
           rescue GraphQL::ExecutionError => err
-            mutation_result = err
-            error_raised = true
+            err
           end
 
           if ctx.schema.lazy?(mutation_result)
             mutation_result
           else
-            build_result(mutation_result, args, ctx, raised: error_raised)
+            build_result(mutation_result, args, ctx)
           end
         end
 
         private
 
-        def build_result(mutation_result, args, ctx, raised: false)
+        def build_result(mutation_result, args, ctx)
           if mutation_result.is_a?(GraphQL::ExecutionError)
             ctx.add_error(mutation_result)
             mutation_result = nil
           end
 
-          if @eager && raised
+          if mutation_result.nil?
             nil
           elsif @wrap_result
             if mutation_result && !mutation_result.is_a?(Hash)

data/lib/graphql/relay/relation_connection.rb

@@ -11,102 +11,139 @@ module GraphQL
         if item_index.nil?
           raise("Can't generate cursor, item not found in connection: #{item}")
         else
-          offset = starting_offset + item_index + 1
+          offset = item_index + 1 + ((relation_offset(paged_nodes) || 0) - (relation_offset(sliced_nodes) || 0))
+
+          if after
+            offset += offset_from_cursor(after)
+          elsif before
+            offset += offset_from_cursor(before) - 1 - sliced_nodes_count
+          end
+
           encode(offset.to_s)
         end
       end
 
       def has_next_page
-        !!(first && paged_nodes && @has_next_page)
+        !!(first && sliced_nodes_count > first)
       end
 
       def has_previous_page
-        !!(last && starting_offset > 0)
+        !!(last && sliced_nodes_count > last)
       end
 
-      private
+      def first
+        return @first if defined? @first
 
-      # If a relation contains a `.group` clause, a `.count` will return a Hash.
-      def count(nodes)
-        count_or_hash = nodes.count
-        count_or_hash.is_a?(Integer) ? count_or_hash : count_or_hash.length
+        @first = get_limited_arg(:first)
+        @first = max_page_size if @first && max_page_size && @first > max_page_size
+        @first
       end
 
+      def last
+        return @last if defined? @last
+
+        @last = get_limited_arg(:last)
+        @last = max_page_size if @last && max_page_size && @last > max_page_size
+        @last
+      end
+
+      private
+
       # apply first / last limit results
       def paged_nodes
-        @paged_nodes ||= begin
-          if limit
-            limit_more = limit + 1
-            more_nodes = sliced_nodes.limit(limit_more).to_a
-            if more_nodes.size > limit
-              @has_next_page = true
-              more_nodes[0..-2]
-            else
-              @has_next_page = false
-              more_nodes
+        return @paged_nodes if defined? @paged_nodes
+
+        items = sliced_nodes
+
+        if first
+          if relation_limit(items).nil? || relation_limit(items) > first
+            items = items.limit(first)
+          end
+        end
+
+        if last
+          if relation_limit(items)
+            if last <= relation_limit(items)
+              offset = (relation_offset(items) || 0) + (relation_limit(items) - last)
+              items = items.offset(offset).limit(last)
             end
           else
-            @has_next_page = false
-            sliced_nodes
+            offset = (relation_offset(items) || 0) + relation_count(items) - last
+            items = items.offset(offset).limit(last)
           end
         end
-      end
 
-      # Apply cursors to edges
-      def sliced_nodes
-        @sliced_nodes ||= nodes.offset(starting_offset)
-      end
+        if max_page_size && !first && !last
+          if relation_limit(items).nil? || relation_limit(items) > max_page_size
+            items = items.limit(max_page_size)
+          end
+        end
 
-      def offset_from_cursor(cursor)
-        decode(cursor).to_i
+        @paged_nodes = items
       end
 
-      def starting_offset
-        @starting_offset ||= begin
-          if before
-            [previous_offset, 0].max
-          elsif last
-            [count(nodes) - last, 0].max
-          else
-            previous_offset
-          end
+      def relation_offset(relation)
+        case relation
+        when ActiveRecord::Relation
+          relation.offset_value
+        when Sequel::Dataset
+          relation.opts[:offset]
         end
       end
 
-      # Offset from the previous selection, if there was one
-      # Otherwise, zero
-      def previous_offset
-        @previous_offset ||= if after
-          offset_from_cursor(after)
-        elsif before
-          prev_page_size = [max_page_size, last].compact.min || 0
-          offset_from_cursor(before) - prev_page_size - 1
-        else
-          0
+      def relation_limit(relation)
+        case relation
+        when ActiveRecord::Relation
+          relation.limit_value
+        when Sequel::Dataset
+          relation.opts[:limit]
         end
       end
 
-      # Limit to apply to this query:
-      # - find a value from the query
-      # - don't exceed max_page_size
-      # - otherwise, don't limit
-      def limit
-        @limit ||= begin
-          limit_from_arguments = if first
-            first
+      # If a relation contains a `.group` clause, a `.count` will return a Hash.
+      def relation_count(relation)
+        count_or_hash = relation.count
+        count_or_hash.is_a?(Integer) ? count_or_hash : count_or_hash.length
+      end
+
+      # Apply cursors to edges
+      def sliced_nodes
+        return @sliced_nodes if defined? @sliced_nodes
+
+        @sliced_nodes = nodes
+
+        if after
+          offset = (relation_offset(@sliced_nodes) || 0) + offset_from_cursor(after)
+          @sliced_nodes = @sliced_nodes.offset(offset) if after
+        end
+
+        if before && after
+          if offset_from_cursor(after) < offset_from_cursor(before)
+            @sliced_nodes = @sliced_nodes.limit(offset_from_cursor(before) - offset_from_cursor(after) - 1)
           else
-            if previous_offset < 0
-              previous_offset + (last ? last : 0)
-            else
-              last
-            end
+            @sliced_nodes = @sliced_nodes.limit(0)
           end
-          [limit_from_arguments, max_page_size].compact.min
+        elsif before
+          @sliced_nodes = @sliced_nodes.limit(offset_from_cursor(before) - 1)
         end
+
+        @sliced_nodes
+      end
+
+      def sliced_nodes_count
+        return @sliced_nodes_count if defined? @sliced_nodes_count
+
+        # If a relation contains a `.group` clause, a `.count` will return a Hash.
+        @sliced_nodes_count = relation_count(sliced_nodes)
+      end
+
+      def offset_from_cursor(cursor)
+        decode(cursor).to_i
       end
 
       def paged_nodes_array
-        @paged_nodes_array ||= paged_nodes.to_a
+        return @paged_nodes_array if defined?(@paged_nodes_array)
+        @paged_nodes_array = paged_nodes.to_a
       end
     end
 

data/lib/graphql/scalar_type.rb

@@ -80,22 +80,8 @@ module GraphQL
 
     private
 
-    def get_arity(callable)
-      case callable
-      when Proc
-        callable.arity
-      else
-        callable.method(:call).arity
-      end
-    end
-
     def ensure_two_arg(callable, method_name)
-      if get_arity(callable) == 1
-        warn("Scalar coerce functions receive two values (`val` and `ctx`), one-argument functions are deprecated (see #{name}.#{method_name}).")
-        ->(val, ctx) { callable.call(val) }
-      else
-        callable
-      end
+      GraphQL::BackwardsCompatibility.wrap_arity(callable, from: 1, to: 2, name: "#{name}.#{method_name}(val, ctx)")
     end
 
     def coerce_non_null_input(value, ctx)

data/lib/graphql/schema.rb

@@ -6,7 +6,6 @@ require "graphql/schema/default_type_error"
 require "graphql/schema/invalid_type_error"
 require "graphql/schema/instrumented_field_map"
 require "graphql/schema/middleware_chain"
-require "graphql/schema/mask"
 require "graphql/schema/null_mask"
 require "graphql/schema/possible_types"
 require "graphql/schema/rescue_middleware"
@@ -63,8 +62,14 @@ module GraphQL
       :default_mask,
       :cursor_encoder,
       directives: ->(schema, directives) { schema.directives = directives.reduce({}) { |m, d| m[d.name] = d; m  }},
-      instrument: ->(schema, type, instrumenter) { schema.instrumenters[type] << instrumenter },
+      instrument: ->(schema, type, instrumenter, after_built_ins: false) {
+        if type == :field && after_built_ins
+          type = :field_after_built_ins
+        end
+        schema.instrumenters[type] << instrumenter
+      },
       query_analyzer: ->(schema, analyzer) { schema.query_analyzers << analyzer },
+      multiplex_analyzer: ->(schema, analyzer) { schema.multiplex_analyzers << analyzer },
       middleware: ->(schema, middleware) { schema.middleware << middleware },
       lazy_resolve: ->(schema, lazy_class, lazy_value_method) { schema.lazy_methods.set(lazy_class, lazy_value_method) },
       rescue_from: ->(schema, err_class, &block) { schema.rescue_from(err_class, &block)}
@@ -74,7 +79,7 @@ module GraphQL
       :query_execution_strategy, :mutation_execution_strategy, :subscription_execution_strategy,
       :max_depth, :max_complexity,
       :orphan_types, :directives,
-      :query_analyzers, :instrumenters, :lazy_methods,
+      :query_analyzers, :multiplex_analyzers, :instrumenters, :lazy_methods,
       :cursor_encoder,
       :raise_definition_error
 
@@ -89,6 +94,10 @@ module GraphQL
       attr_accessor :default_execution_strategy
     end
 
+    def default_filter
+      GraphQL::Filter.new(except: default_mask)
+    end
+
     self.default_execution_strategy = GraphQL::Execution::Execute
 
     BUILT_IN_TYPES = Hash[[INT_TYPE, STRING_TYPE, FLOAT_TYPE, BOOLEAN_TYPE, ID_TYPE].map{ |type| [type.name, type] }]
@@ -104,6 +113,7 @@ module GraphQL
       @static_validator = GraphQL::StaticValidation::Validator.new(schema: self)
       @middleware = MiddlewareChain.new(final_step: GraphQL::Execution::Execute::FieldResolveStep)
       @query_analyzers = []
+      @multiplex_analyzers = []
       @resolve_type_proc = nil
       @object_from_id_proc = nil
       @id_from_object_proc = nil
@@ -127,6 +137,7 @@ module GraphQL
       @static_validator = GraphQL::StaticValidation::Validator.new(schema: self)
       @middleware = other.middleware.dup
       @query_analyzers = other.query_analyzers.dup
+      @multiplex_analyzers = other.multiplex_analyzers.dup
 
       @possible_types = GraphQL::Schema::PossibleTypes.new(self)
 
@@ -211,13 +222,36 @@ module GraphQL
     # Execute a query on itself. Raises an error if the schema definition is invalid.
     # @see {Query#initialize} for arguments.
     # @return [Hash] query result, ready to be serialized as JSON
-    def execute(*args)
-      if @definition_error
-        raise @definition_error
-      else
-        query_obj = GraphQL::Query.new(self, *args)
-        query_obj.result
+    def execute(query_str = nil, **kwargs)
+      if query_str
+        kwargs[:query] = query_str
       end
+      all_results = multiplex([kwargs])
+      all_results[0]
+    end
+
+    # Execute several queries on itself. Raises an error if the schema definition is invalid.
+    # @example Run several queries at once
+    #   context = { ... }
+    #   queries = [
+    #     { query: params[:query_1], variables: params[:variables_1], context: context },
+    #     { query: params[:query_2], variables: params[:variables_2], context: context },
+    #   ]
+    #   results = MySchema.multiplex(queries)
+    #   render json: {
+    #     result_1: results[0],
+    #     result_2: results[1],
+    #   }
+    #
+    # @see {Query#initialize} for query keyword arguments
+    # @see {Execution::Multiplex#run_queries} for multiplex keyword arguments
+    # @param queries [Array<Hash>] Keyword arguments for each query
+    # @param context [Hash] Multiplex-level context
+    # @return [Array<Hash>] One result for each query in the input
+    def multiplex(*args)
+      with_definition_error_check {
+        GraphQL::Execution::Multiplex.run_all(self, *args)
+      }
     end
 
     # Resolve field named `field_name` for type `parent_type`.
@@ -225,17 +259,19 @@ module GraphQL
     # @see [GraphQL::Schema::Warden] Restricted access to members of a schema
     # @return [GraphQL::Field, nil] The field named `field_name` on `parent_type`
     def get_field(parent_type, field_name)
-      defined_field = @instrumented_field_map.get(parent_type.name, field_name)
-      if defined_field
-        defined_field
-      elsif field_name == "__typename"
-        GraphQL::Introspection::TypenameField
-      elsif field_name == "__schema" && parent_type == query
-        GraphQL::Introspection::SchemaField
-      elsif field_name == "__type" && parent_type == query
-        GraphQL::Introspection::TypeByNameField
-      else
-        nil
+      with_definition_error_check do
+        defined_field = @instrumented_field_map.get(parent_type.name, field_name)
+        if defined_field
+          defined_field
+        elsif field_name == "__typename"
+          GraphQL::Introspection::TypenameField
+        elsif field_name == "__schema" && parent_type == query
+          GraphQL::Introspection::SchemaField
+        elsif field_name == "__type" && parent_type == query
+          GraphQL::Introspection::TypeByNameField
+        else
+          nil
+        end
       end
     end
 
@@ -419,14 +455,31 @@ module GraphQL
       !!lazy_method_name(obj)
     end
 
-    # Return a GraphQL schema string for the defined types in the schema
+    # Return the GraphQL IDL for the schema
     # @param context [Hash]
     # @param only [<#call(member, ctx)>]
     # @param except [<#call(member, ctx)>]
+    # @return [String]
     def to_definition(only: nil, except: nil, context: {})
       GraphQL::Schema::Printer.print_schema(self, only: only, except: except, context: context)
     end
 
+    # Return the Hash response of {Introspection::INTROSPECTION_QUERY}.
+    # @param context [Hash]
+    # @param only [<#call(member, ctx)>]
+    # @param except [<#call(member, ctx)>]
+    # @return [Hash] GraphQL result
+    def as_json(only: nil, except: nil, context: {})
+      execute(Introspection::INTROSPECTION_QUERY, only: only, except: except, context: context)
+    end
+
+    # Returns the JSON response of {Introspection::INTROSPECTION_QUERY}.
+    # @see {#as_json}
+    # @return [String]
+    def to_json(*args)
+      JSON.pretty_generate(as_json(*args))
+    end
+
     protected
 
     def rescues?
@@ -441,14 +494,18 @@ module GraphQL
 
     private
 
+    # Wrap Relay-related objects in wrappers
+    # @api private
+    BUILT_IN_INSTRUMENTERS = [
+      GraphQL::Relay::ConnectionInstrumentation,
+      GraphQL::Relay::Mutation::Instrumentation,
+    ]
+
     # Apply instrumentation to fields. Relay instrumentation is applied last
     # so that user-provided instrumentation can wrap user-provided resolve functions,
     # _then_ Relay helpers can wrap the returned objects.
     def build_instrumented_field_map
-      all_instrumenters = @instrumenters[:field] + [
-        GraphQL::Relay::ConnectionInstrumentation,
-        GraphQL::Relay::Mutation::Instrumentation,
-      ]
+      all_instrumenters = @instrumenters[:field] + BUILT_IN_INSTRUMENTERS + @instrumenters[:field_after_built_ins]
       @instrumented_field_map = InstrumentedFieldMap.new(self, all_instrumenters)
     end
 
@@ -456,5 +513,13 @@ module GraphQL
       all_types = orphan_types + [query, mutation, subscription, GraphQL::Introspection::SchemaType]
       @types = GraphQL::Schema::ReduceTypes.reduce(all_types.compact)
     end
+
+    def with_definition_error_check
+      if @definition_error
+        raise @definition_error
+      else
+        yield
+      end
+    end
   end
 end