graphql 1.7.0 → 1.7.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 143f5c1d1fd648361bc54f779e9e160d5953a439
-  data.tar.gz: a17369262755499d3adfa17be3465ac4d68e6c97
+  metadata.gz: d524553e65b5b66f89705c436377523f7d4ac976
+  data.tar.gz: 8cb44e1162bc0b1aa1be8fb8c78665f5bd8f20e9
 SHA512:
-  metadata.gz: d9d383e0fcb02bd527c830c157ce0e6b97a8f3b552f75d6e6be28f51f82296168bfea5e81f4e06463d706d2dc264095aa38b048d35e3afc432379b5482d6afd7
-  data.tar.gz: a22957f865c6145c04af2f68b1810f799caa873a60cc3788607505c63be52fbaa9f393a9bf2809a85e64e5625efbe83ceeab2642f7c29ef4d952c1391c9ac3e7
+  metadata.gz: 8eb7ed959efa258714dab38486844d32c75a17a4040c89db3478c2b151e4222982ecfcc41a48b82b0a08df1b54aa871a1567bfcdd043ede9abba1b69b31fe3c8
+  data.tar.gz: 9f753512aec476ebeab407d159c80b75d94aedfb74d8d266910e73c7a88b1934f53bf1f643498eb8bb32798b500c3cfb086a6d9e7f928d993b04a650b5fde0d9

data/lib/graphql/directive.rb

@@ -10,7 +10,7 @@ module GraphQL
     include GraphQL::Define::InstanceDefinable
     accepts_definitions :locations, :name, :description, :arguments, :default_directive, argument: GraphQL::Define::AssignArgument
 
-    attr_accessor :locations, :arguments, :name, :description
+    attr_accessor :locations, :arguments, :name, :description, :arguments_class
     # @api private
     attr_writer :default_directive
     ensure_defined(:locations, :arguments, :name, :description, :default_directive?)

data/lib/graphql/field.rb

@@ -179,6 +179,8 @@ module GraphQL
     # @return [Object, GraphQL::Function] The function used to derive this field
     attr_accessor :function
 
+    attr_accessor :arguments_class
+
     attr_writer :connection
 
     # @return [nil, String] Prefix for subscription names from this field

data/lib/graphql/input_object_type.rb

@@ -30,7 +30,7 @@ module GraphQL
       argument: GraphQL::Define::AssignArgument
     )
 
-    attr_accessor :mutation, :arguments
+    attr_accessor :mutation, :arguments, :arguments_class
     ensure_defined(:mutation, :arguments, :input_fields)
     alias :input_fields :arguments
 
@@ -96,7 +96,7 @@ module GraphQL
         end
       end
 
-      GraphQL::Query::Arguments.new(input_values, argument_definitions: arguments)
+      arguments_class.instantiate_arguments(input_values)
     end
 
     # @api private

data/lib/graphql/query/arguments.rb

@@ -1,12 +1,59 @@
 # frozen_string_literal: true
 module GraphQL
   class Query
+    class StaticArguments
+      attr_reader :argument_definitions
+
+      def initialize(argument_definitions:)
+        @argument_definitions = argument_definitions
+      end
+
+      def instantiate_arguments(values)
+        arg_class.new(values, argument_definitions: argument_definitions)
+      end
+
+      private
+
+      def arg_class
+        @arg_class ||= begin
+          klass = Class.new(GraphQL::Query::Arguments).instance_exec(self) do |static_arguments|
+            static_arguments.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]
+              end
+            end
+
+            self
+          end
+
+          klass
+        end
+      end
+    end
+
     # Read-only access to values, normalizing all keys to strings
     #
     # {Arguments} recursively wraps the input in {Arguments} instances.
     class Arguments
       extend GraphQL::Delegate
 
+      def self.construct_arguments_class(argument_owner)
+        arguments_class = GraphQL::Query::StaticArguments.new(argument_definitions: argument_owner.arguments)
+        argument_owner.arguments_class = arguments_class
+      end
+
       def initialize(values, argument_definitions:)
         @argument_values = values.inject({}) do |memo, (inner_key, inner_value)|
           arg_defn = argument_definitions[inner_key.to_s]

data/lib/graphql/query/arguments_cache.rb

@@ -8,13 +8,12 @@ module GraphQL
         Hash.new do |h1, irep_or_ast_node|
           h1[irep_or_ast_node] = Hash.new do |h2, definition|
             ast_node = irep_or_ast_node.is_a?(GraphQL::InternalRepresentation::Node) ? irep_or_ast_node.ast_node : irep_or_ast_node
-            ast_arguments = ast_node.arguments
             h2[definition] = if definition.arguments.none?
               GraphQL::Query::Arguments::NO_ARGS
             else
               GraphQL::Query::LiteralInput.from_arguments(
-                ast_arguments,
-                definition.arguments,
+                ast_node.arguments,
+                definition,
                 query.variables,
               )
             end

data/lib/graphql/query/literal_input.rb

@@ -41,21 +41,12 @@ module GraphQL
           when GraphQL::InputObjectType
             # TODO smell: handling AST vs handling plain Ruby
             next_args = ast_node.is_a?(Hash) ? ast_node : ast_node.arguments
-            from_arguments(next_args, type.arguments, variables)
+            from_arguments(next_args, type, variables)
           end
         end
       end
 
-      def self.defaults_for(argument_defns)
-        if argument_defns.values.none?(&:default_value?)
-          GraphQL::Query::Arguments::NO_ARGS
-        else
-          from_arguments([], argument_defns, nil)
-        end
-      end
-
-      def self.from_arguments(ast_arguments, argument_defns, variables)
-        # Variables is nil when making .defaults_for
+      def self.from_arguments(ast_arguments, argument_owner, variables)
         context = variables ? variables.context : nil
         values_hash = {}
         indexed_arguments = case ast_arguments
@@ -67,6 +58,7 @@ module GraphQL
           raise ArgumentError, "Unexpected ast_arguments: #{ast_arguments}"
         end
 
+        argument_defns = argument_owner.arguments
         argument_defns.each do |arg_name, arg_defn|
           ast_arg = indexed_arguments[arg_name]
           # First, check the argument in the AST.
@@ -113,7 +105,7 @@ module GraphQL
           end
         end
 
-        GraphQL::Query::Arguments.new(values_hash, argument_definitions: argument_defns)
+        argument_owner.arguments_class.instantiate_arguments(values_hash)
       end
     end
   end

data/lib/graphql/relay/array_connection.rb

@@ -7,6 +7,30 @@ module GraphQL
         encode(idx.to_s)
       end
 
+      def has_next_page
+        if first
+          # There are more items after these items
+          sliced_nodes.count > first
+        elsif GraphQL::Relay::ConnectionType.bidirectional_pagination && before
+          # The original array is longer than the `before` index
+          index_from_cursor(before) < nodes.length
+        else
+          false
+        end
+      end
+
+      def has_previous_page
+        if last
+          # There are items preceding the ones in this result
+          sliced_nodes.count > last
+        elsif GraphQL::Relay::ConnectionType.bidirectional_pagination && after
+          # We've paginated into the Array a bit, there are some behind us
+          index_from_cursor(after) > 0
+        else
+          false
+        end
+      end
+
       private
 
       def first

data/lib/graphql/relay/connection_type.rb

@@ -3,10 +3,14 @@ module GraphQL
   module Relay
     module ConnectionType
       class << self
+        # @return [Boolean] If true, connection types get a `nodes` shortcut field
         attr_accessor :default_nodes_field
+        # @return [Boolean] If true, connections check for reverse-direction `has*Page` values
+        attr_accessor :bidirectional_pagination
       end
 
       self.default_nodes_field = false
+      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)

data/lib/graphql/relay/relation_connection.rb

@@ -24,11 +24,25 @@ module GraphQL
       end
 
       def has_next_page
-        !!(first && paged_nodes_length >= first && sliced_nodes_count > first)
+        if first
+          paged_nodes_length >= first && sliced_nodes_count > first
+        elsif GraphQL::Relay::ConnectionType.bidirectional_pagination && last
+          sliced_nodes_count > last
+        else
+          false
+        end
       end
 
       def has_previous_page
-        !!(last && paged_nodes_length >= last && sliced_nodes_count > last)
+        if 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
+          offset_from_cursor(after) > 0
+        else
+          false
+        end
       end
 
       def first

data/lib/graphql/schema/traversal.rb

@@ -42,6 +42,11 @@ module GraphQL
           visit_roots = [member.query, member.mutation, member.subscription]
           if @introspection
             visit_roots << GraphQL::Introspection::SchemaType
+            if member.query
+              # Visit this so that arguments class is preconstructed
+              # Skip validation since it begins with __
+              visit_field_on_type(member.query, GraphQL::Introspection::TypeByNameField, dynamic_field: true)
+            end
           end
           visit_roots.concat(member.orphan_types)
           visit_roots.compact!
@@ -51,6 +56,9 @@ module GraphQL
             @type_reference_map[argument.type.unwrap.to_s] << argument
             visit(argument.type, "Directive argument #{member.name}.#{name}")
           end
+          # Construct arguments class here, which is later used to generate GraphQL::Query::Arguments
+          # to be passed to a resolver proc
+          GraphQL::Query::Arguments.construct_arguments_class(member)
         when GraphQL::BaseType
           type_defn = member.unwrap
           prev_type = @type_map[type_defn.name]
@@ -74,6 +82,10 @@ module GraphQL
                 @type_reference_map[arg.type.unwrap.to_s] << arg
                 visit(arg.type, "Input field #{type_defn.name}.#{name}")
               end
+
+              # Construct arguments class here, which is later used to generate GraphQL::Query::Arguments
+              # to be passed to a resolver proc
+              GraphQL::Query::Arguments.construct_arguments_class(type_defn)
             end
           elsif !prev_type.equal?(type_defn)
             # If the previous entry in the map isn't the same object we just found, raise.
@@ -87,17 +99,28 @@ module GraphQL
 
       def visit_fields(type_defn)
         type_defn.all_fields.each do |field_defn|
-          instrumented_field_defn = @field_instrumenters.reduce(field_defn) do |defn, inst|
-            inst.instrument(type_defn, defn)
-          end
+          visit_field_on_type(type_defn, field_defn)
+        end
+      end
+
+      def visit_field_on_type(type_defn, field_defn, dynamic_field: false)
+        instrumented_field_defn = @field_instrumenters.reduce(field_defn) do |defn, inst|
+          inst.instrument(type_defn, defn)
+        end
+        if !dynamic_field
           @instrumented_field_map[type_defn.name][instrumented_field_defn.name] = instrumented_field_defn
-          @type_reference_map[instrumented_field_defn.type.unwrap.name] << instrumented_field_defn
-          visit(instrumented_field_defn.type, "Field #{type_defn.name}.#{instrumented_field_defn.name}'s return type")
-          instrumented_field_defn.arguments.each do |name, arg|
-            @type_reference_map[arg.type.unwrap.to_s] << arg
-            visit(arg.type, "Argument #{name} on #{type_defn.name}.#{instrumented_field_defn.name}")
-          end
         end
+        @type_reference_map[instrumented_field_defn.type.unwrap.name] << instrumented_field_defn
+        visit(instrumented_field_defn.type, "Field #{type_defn.name}.#{instrumented_field_defn.name}'s return type")
+
+        instrumented_field_defn.arguments.each do |name, arg|
+          @type_reference_map[arg.type.unwrap.to_s] << arg
+          visit(arg.type, "Argument #{name} on #{type_defn.name}.#{instrumented_field_defn.name}")
+        end
+
+        # Construct arguments class here, which is later used to generate GraphQL::Query::Arguments
+        # to be passed to a resolver proc
+        GraphQL::Query::Arguments.construct_arguments_class(instrumented_field_defn)
       end
 
       def validate_type(member, context_description)

data/lib/graphql/subscriptions/event.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# test_via: ../subscriptions.rb
 module GraphQL
   class Subscriptions
     # This thing can be:
@@ -37,7 +38,7 @@ module GraphQL
         when Hash
           GraphQL::Query::LiteralInput.from_arguments(
             arguments,
-            field.arguments,
+            field,
             nil,
           )
         else

data/lib/graphql/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module GraphQL
-  VERSION = "1.7.0"
+  VERSION = "1.7.1"
 end

data/spec/graphql/input_object_type_spec.rb

@@ -182,7 +182,7 @@ describe GraphQL::InputObjectType do
 
         it "has problem with correct path" do
           paths = result.problems.map { |p| p["path"] }
-          assert_equal(paths, [["isDelicious"]])
+          assert_equal([["isDelicious"]], paths)
         end
 
         it "has correct problem explanation" do

data/spec/graphql/list_type_spec.rb

@@ -37,10 +37,14 @@ describe GraphQL::ListType do
 
   describe "list of input objects" do
     let(:input_object) do
-      GraphQL::InputObjectType.define do
+      input_object = GraphQL::InputObjectType.define do
         name "SomeInputObjectType"
         argument :float, !types.Float
       end
+
+      GraphQL::Query::Arguments.construct_arguments_class(input_object)
+
+      input_object
     end
 
     let(:input_object_list) { input_object.to_list_type }

data/spec/graphql/query/arguments_spec.rb

@@ -291,4 +291,23 @@ describe GraphQL::Query::Arguments do
       assert_equal 30, args['inputObject']['a']
     end
   end
+
+  describe "construct_arguments_class" do
+    let(:input_object) do
+      GraphQL::InputObjectType.define do
+        argument :foo, types.Int
+        argument :bar, types.Int
+      end
+    end
+
+    it "generates argument classes that responds to keys as functions" do
+      assert_equal nil, input_object.arguments_class
+
+      GraphQL::Query::Arguments.construct_arguments_class(input_object)
+      args = input_object.arguments_class.instantiate_arguments({foo: 3, bar: -90})
+
+      assert_equal 3, args.foo
+      assert_equal -90, args.bar
+    end
+  end
 end

data/spec/graphql/relay/array_connection_spec.rb

@@ -11,6 +11,10 @@ describe GraphQL::Relay::ArrayConnection do
     result["data"]["rebels"]["ships"]["edges"].last["cursor"]
   end
 
+  def get_page_info(result, key = "bases")
+    result["data"]["rebels"][key]["pageInfo"]
+  end
+
   describe "results" do
     let(:query_string) {%|
       query getShips($first: Int, $after: String, $last: Int, $before: String, $nameIncludes: String){
@@ -61,6 +65,36 @@ describe GraphQL::Relay::ArrayConnection do
       assert_equal("NQ==", result["data"]["rebels"]["ships"]["pageInfo"]["endCursor"])
     end
 
+    it "provides bidirectional_pagination" do
+      result = star_wars_query(query_string, "first" => 1)
+      last_cursor = get_last_cursor(result)
+
+      # When going forwards, bi-directional pagination
+      # returns `true` even for `hasPreviousPage`
+      result = star_wars_query(query_string, "first" => 1, "after" => last_cursor)
+      assert_equal(true, get_page_info(result, "ships")["hasNextPage"])
+      assert_equal(false, get_page_info(result, "ships")["hasPreviousPage"])
+
+      result = with_bidirectional_pagination {
+        star_wars_query(query_string, "first" => 3, "after" => last_cursor)
+      }
+      assert_equal(true, get_page_info(result, "ships")["hasNextPage"])
+      assert_equal(true, get_page_info(result, "ships")["hasPreviousPage"])
+
+      # When going backwards, bi-directional pagination
+      # returns true for `hasNextPage`
+      last_cursor = get_last_cursor(result)
+      result = star_wars_query(query_string, "last" => 1, "before" => last_cursor)
+      assert_equal(false, get_page_info(result, "ships")["hasNextPage"])
+      assert_equal(true, get_page_info(result, "ships")["hasPreviousPage"])
+
+      result = with_bidirectional_pagination {
+        star_wars_query(query_string, "last" => 2, "before" => last_cursor)
+      }
+      assert_equal(true, get_page_info(result, "ships")["hasNextPage"])
+      assert_equal(true, get_page_info(result, "ships")["hasPreviousPage"])
+    end
+
     it 'slices the result' do
       result = star_wars_query(query_string, "first" => 1)
       assert_equal(["X-Wing"], get_names(result))
@@ -142,10 +176,6 @@ describe GraphQL::Relay::ArrayConnection do
         result["data"]["rebels"]["bases"]["edges"].map { |e| e["node"]["name"] }
       end
 
-      def get_page_info(result)
-        result["data"]["rebels"]["bases"]["pageInfo"]
-      end
-
       let(:query_string) {%|
         query getShips($first: Int, $after: String, $last: Int, $before: String){
           rebels {

data/spec/graphql/relay/relation_connection_spec.rb

@@ -74,6 +74,35 @@ describe GraphQL::Relay::RelationConnection do
       )
     end
 
+    it "provides bidirectional_pagination" do
+      result = star_wars_query(query_string, "first" => 1)
+      last_cursor = get_last_cursor(result)
+
+      result = star_wars_query(query_string, "first" => 1, "after" => last_cursor)
+      assert_equal true, get_page_info(result)["hasNextPage"]
+      assert_equal false, get_page_info(result)["hasPreviousPage"]
+
+      result = with_bidirectional_pagination {
+        star_wars_query(query_string, "first" => 1, "after" => last_cursor)
+      }
+      assert_equal true, get_page_info(result)["hasNextPage"]
+      assert_equal true, get_page_info(result)["hasPreviousPage"]
+
+      result = star_wars_query(query_string, "first" => 100)
+      last_cursor = get_last_cursor(result)
+
+      result = star_wars_query(query_string, "last" => 1, "before" => last_cursor)
+      assert_equal false, get_page_info(result)["hasNextPage"]
+      assert_equal true, get_page_info(result)["hasPreviousPage"]
+
+      result = with_bidirectional_pagination {
+        star_wars_query(query_string, "last" => 1, "before" => last_cursor)
+      }
+      assert_equal true, get_page_info(result)["hasNextPage"]
+      assert_equal true, get_page_info(result)["hasPreviousPage"]
+
+    end
+
     it 'slices the result' do
       result = star_wars_query(query_string, "first" => 2)
       assert_equal(["Death Star", "Shield Generator"], get_names(result))

data/spec/spec_helper.rb

@@ -68,6 +68,14 @@ def star_wars_query(string, variables={}, context: {})
   GraphQL::Query.new(StarWars::Schema, string, variables: variables, context: context).result
 end
 
+def with_bidirectional_pagination
+  prev_value = GraphQL::Relay::ConnectionType.bidirectional_pagination
+  GraphQL::Relay::ConnectionType.bidirectional_pagination = true
+  yield
+ensure
+  GraphQL::Relay::ConnectionType.bidirectional_pagination = prev_value
+end 
+
 module TestTracing
   class << self
     def clear

data/spec/support/dummy/schema.rb

@@ -109,7 +109,7 @@ module Dummy
     field :flavors, types[types.String], "Chocolate, Strawberry, etc" do
       argument :limit, types.Int
       resolve ->(milk, args, ctx) {
-        args[:limit] ? milk.flavors.first(args[:limit]) : milk.flavors
+        args[:limit] ? milk.flavors.first(args.limit) : milk.flavors
       }
     end
     field :executionError do
@@ -234,7 +234,7 @@ module Dummy
     name "DeepNonNull"
     field :nonNullInt, !types.Int do
       argument :returning, types.Int
-      resolve ->(obj, args, ctx) { args[:returning] }
+      resolve ->(obj, args, ctx) { args.returning }
     end
 
     field :deepNonNull, DeepNonNullType.to_non_null_type do
@@ -328,7 +328,7 @@ module Dummy
       argument :executionErrorAtIndex, types.Int
       resolve ->(obj, args, ctx) {
         result = CHEESES.values + MILKS.values
-        result[args[:executionErrorAtIndex]] = GraphQL::ExecutionError.new("missing dairy") if args[:executionErrorAtIndex]
+        result[args.executionErrorAtIndex] = GraphQL::ExecutionError.new("missing dairy") if args.executionErrorAtIndex
         result
       }
     end
@@ -384,7 +384,7 @@ module Dummy
       description("Push a value onto a global array :D")
       argument :value, !types.Int, as: :val
       resolve ->(o, args, ctx) {
-        GLOBAL_VALUES << args[:val]
+        GLOBAL_VALUES << args.val
         GLOBAL_VALUES
       }
     end
@@ -394,7 +394,7 @@ module Dummy
       argument :input, !ReplaceValuesInputType
       resolve ->(o, args, ctx) {
         GLOBAL_VALUES.clear
-        GLOBAL_VALUES.push(*args[:input][:values])
+        GLOBAL_VALUES.push(*args.input[:values])
         GLOBAL_VALUES
       }
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: graphql
 version: !ruby/object:Gem::Version
-  version: 1.7.0
+  version: 1.7.1
 platform: ruby
 authors:
 - Robert Mosolgo