graphql 1.10.5 → 1.10.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ace6be63c92b2a2139381664968aef4eeed01a5b1e3936af31ef3b0d7735b944
-  data.tar.gz: 6d572562697f474dc82f81e3c28e9d234bf9348ef2446db41a10fa4b6d52cec4
+  metadata.gz: 1b006fe34754dbc2e3ee7ef459e05bdf325755538e013efd96c9eef3990af9a7
+  data.tar.gz: b655b349e59ea3a34d6ed71fb3870af1cc91afc75bf7147cb0d9b436b78a97c8
 SHA512:
-  metadata.gz: 4da367c261c3fd79192aea827be4b0cebc864820d4dba6ed74a3c57d9c7772511bf6b96bdd4316e9186bd751954a964b09bc1e455fed4f687edb958d869f25e5
-  data.tar.gz: a5d4c7c349cebf6ce1e064763c47a61e6018a29d4b563ce833390ed5d378f5dd977b884f2a1809a7935e43902a9e33e23682662192cc3ff5ab8079c75c1b5fb6
+  metadata.gz: 9a07c35f18dfdb53924fc9ff8466c3255c7235f855d5ea7380738e4cde90c47c6cd12aaa505a27ee1c3ec3bee84a8a82ed9ec113cbbd362ef152a8b1ec6cdf38
+  data.tar.gz: 23e61762fd23870cb651334aa84a9e83bb9dda486b114ea8bb2b937eeb77705bac200255b321983caf4f81d6efd0b231a992b618563b86d6446b68585ec429bc

data/lib/generators/graphql/install_generator.rb

@@ -87,6 +87,11 @@ module Graphql
         default: false,
         desc: "Include GraphQL::Batch installation"
 
+      class_option :playground,
+        type: :boolean,
+        default: false,
+        desc: "Use GraphQL Playground over Graphiql as IDE"
+
       # These two options are taken from Rails' own generators'
       class_option :api,
         type: :boolean,
@@ -140,6 +145,28 @@ RUBY
           end
         end
 
+        if options[:playground]
+          gem("graphql_playground-rails", group: :development)
+
+          log :route, 'graphql_playground-rails'
+          shell.mute do
+            if Rails::VERSION::STRING > "5.2"
+              route <<-RUBY
+if Rails.env.development?
+  mount GraphqlPlayground::Rails::Engine, at: "/playground", graphql_path: "/graphql"
+end
+RUBY
+            else
+              route <<-RUBY
+if Rails.env.development?
+    mount GraphqlPlayground::Rails::Engine, at: "/playground", graphql_path: "/graphql"
+  end
+RUBY
+            end
+          end
+
+        end
+
         if gemfile_modified?
           say "Gemfile has been modified, make sure you `bundle install`"
         end

data/lib/generators/graphql/templates/graphql_controller.erb

@@ -43,6 +43,6 @@ class GraphqlController < ApplicationController
     logger.error e.message
     logger.error e.backtrace.join("\n")
 
-    render json: { error: { message: e.message, backtrace: e.backtrace }, data: {} }, status: 500
+    render json: { errors: [{ message: e.message, backtrace: e.backtrace }], data: {} }, status: 500
   end
 end

data/lib/graphql/execution/interpreter.rb

@@ -92,6 +92,19 @@ module GraphQL
           Interpreter::Resolve.resolve_all(final_values)
         end
       end
+
+      class ListResultFailedError < GraphQL::Error
+        def initialize(value:, path:, field:)
+          message = "Failed to build a GraphQL list result for field `#{field.path}` at path `#{path.join(".")}`.\n".dup
+
+          message << "Expected `#{value.inspect}` to implement `.each` to satisfy the GraphQL return type `#{field.type.to_type_signature}`.\n"
+
+          if field.connection?
+            message << "\nThis field was treated as a Relay-style connection; add `connection: false` to the `field(...)` to disable this behavior."
+          end
+          super(message)
+        end
+      end
     end
   end
 end

data/lib/graphql/execution/interpreter/arguments_cache.rb

@@ -12,7 +12,16 @@ module GraphQL
                 # First, normalize all AST or Ruby values to a plain Ruby hash
                 args_hash = prepare_args_hash(ast_node)
                 # Then call into the schema to coerce those incoming values
-                arg_owner.coerce_arguments(parent_object, args_hash, query.context)
+                args = arg_owner.coerce_arguments(parent_object, args_hash, query.context)
+
+                h3[parent_object] = if args.is_a?(GraphQL::Execution::Lazy)
+                  args.then { |resolved_args|
+                    # when this promise is resolved, update the cache with the resolved value
+                    h3[parent_object] = resolved_args
+                  }
+                else
+                  args
+                end
               end
             end
           end

data/lib/graphql/execution/interpreter/runtime.rb

@@ -174,69 +174,71 @@ module GraphQL
               next
             end
 
-            # It might turn out that making arguments for every field is slow.
-            # If we have to cache them, we'll need a more subtle approach here.
-            field_defn.extras.each do |extra|
-              case extra
-              when :ast_node
-                kwarg_arguments[:ast_node] = ast_node
-              when :execution_errors
-                kwarg_arguments[:execution_errors] = ExecutionErrors.new(context, ast_node, next_path)
-              when :path
-                kwarg_arguments[:path] = next_path
-              when :lookahead
-                if !field_ast_nodes
-                  field_ast_nodes = [ast_node]
+            after_lazy(kwarg_arguments, owner: owner_type, field: field_defn, path: next_path, scoped_context: context.scoped_context, owner_object: object, arguments: kwarg_arguments) do |kwarg_arguments|
+              # It might turn out that making arguments for every field is slow.
+              # If we have to cache them, we'll need a more subtle approach here.
+              field_defn.extras.each do |extra|
+                case extra
+                when :ast_node
+                  kwarg_arguments[:ast_node] = ast_node
+                when :execution_errors
+                  kwarg_arguments[:execution_errors] = ExecutionErrors.new(context, ast_node, next_path)
+                when :path
+                  kwarg_arguments[:path] = next_path
+                when :lookahead
+                  if !field_ast_nodes
+                    field_ast_nodes = [ast_node]
+                  end
+                  kwarg_arguments[:lookahead] = Execution::Lookahead.new(
+                    query: query,
+                    ast_nodes: field_ast_nodes,
+                    field: field_defn,
+                  )
+                else
+                  kwarg_arguments[extra] = field_defn.fetch_extra(extra, context)
                 end
-                kwarg_arguments[:lookahead] = Execution::Lookahead.new(
-                  query: query,
-                  ast_nodes: field_ast_nodes,
-                  field: field_defn,
-                )
-              else
-                kwarg_arguments[extra] = field_defn.fetch_extra(extra, context)
               end
-            end
 
-            @interpreter_context[:current_arguments] = kwarg_arguments
+              @interpreter_context[:current_arguments] = kwarg_arguments
 
-            # Optimize for the case that field is selected only once
-            if field_ast_nodes.nil? || field_ast_nodes.size == 1
-              next_selections = ast_node.selections
-            else
-              next_selections = []
-              field_ast_nodes.each { |f| next_selections.concat(f.selections) }
-            end
+              # Optimize for the case that field is selected only once
+              if field_ast_nodes.nil? || field_ast_nodes.size == 1
+                next_selections = ast_node.selections
+              else
+                next_selections = []
+                field_ast_nodes.each { |f| next_selections.concat(f.selections) }
+              end
 
-            field_result = resolve_with_directives(object, ast_node) do
-              # Actually call the field resolver and capture the result
-              app_result = begin
-                query.with_error_handling do
-                  query.trace("execute_field", {owner: owner_type, field: field_defn, path: next_path, query: query, object: object, arguments: kwarg_arguments}) do
-                    field_defn.resolve(object, kwarg_arguments, context)
+              field_result = resolve_with_directives(object, ast_node) do
+                # Actually call the field resolver and capture the result
+                app_result = begin
+                  query.with_error_handling do
+                    query.trace("execute_field", {owner: owner_type, field: field_defn, path: next_path, query: query, object: object, arguments: kwarg_arguments}) do
+                      field_defn.resolve(object, kwarg_arguments, context)
+                    end
                   end
+                rescue GraphQL::ExecutionError => err
+                  err
                 end
-              rescue GraphQL::ExecutionError => err
-                err
-              end
-              after_lazy(app_result, owner: owner_type, field: field_defn, path: next_path, scoped_context: context.scoped_context, owner_object: object, arguments: kwarg_arguments) do |inner_result|
-                continue_value = continue_value(next_path, inner_result, field_defn, return_type.non_null?, ast_node)
-                if RawValue === continue_value
-                  # Write raw value directly to the response without resolving nested objects
-                  write_in_response(next_path, continue_value.resolve)
-                elsif HALT != continue_value
-                  continue_field(next_path, continue_value, field_defn, return_type, ast_node, next_selections, false, object, kwarg_arguments)
+                after_lazy(app_result, owner: owner_type, field: field_defn, path: next_path, scoped_context: context.scoped_context, owner_object: object, arguments: kwarg_arguments) do |inner_result|
+                  continue_value = continue_value(next_path, inner_result, field_defn, return_type.non_null?, ast_node)
+                  if RawValue === continue_value
+                    # Write raw value directly to the response without resolving nested objects
+                    write_in_response(next_path, continue_value.resolve)
+                  elsif HALT != continue_value
+                    continue_field(next_path, continue_value, field_defn, return_type, ast_node, next_selections, false, object, kwarg_arguments)
+                  end
                 end
               end
-            end
 
-            # If this field is a root mutation field, immediately resolve
-            # all of its child fields before moving on to the next root mutation field.
-            # (Subselections of this mutation will still be resolved level-by-level.)
-            if root_operation_type == "mutation"
-              Interpreter::Resolve.resolve_all([field_result])
-            else
-              field_result
+              # If this field is a root mutation field, immediately resolve
+              # all of its child fields before moving on to the next root mutation field.
+              # (Subselections of this mutation will still be resolved level-by-level.)
+              if root_operation_type == "mutation"
+                Interpreter::Resolve.resolve_all([field_result])
+              else
+                field_result
+              end
             end
           end
         end
@@ -330,20 +332,26 @@ module GraphQL
             inner_type = type.of_type
             idx = 0
             scoped_context = context.scoped_context
-            value.each do |inner_value|
-              next_path = path.dup
-              next_path << idx
-              next_path.freeze
-              idx += 1
-              set_type_at_path(next_path, inner_type)
-              # This will update `response_list` with the lazy
-              after_lazy(inner_value, owner: inner_type, path: next_path, scoped_context: scoped_context, field: field, owner_object: owner_object, arguments: arguments) do |inner_inner_value|
-                continue_value = continue_value(next_path, inner_inner_value, field, inner_type.non_null?, ast_node)
-                if HALT != continue_value
-                  continue_field(next_path, continue_value, field, inner_type, ast_node, next_selections, false, owner_object, arguments)
+            begin
+              value.each do |inner_value|
+                next_path = path.dup
+                next_path << idx
+                next_path.freeze
+                idx += 1
+                set_type_at_path(next_path, inner_type)
+                # This will update `response_list` with the lazy
+                after_lazy(inner_value, owner: inner_type, path: next_path, scoped_context: scoped_context, field: field, owner_object: owner_object, arguments: arguments) do |inner_inner_value|
+                  continue_value = continue_value(next_path, inner_inner_value, field, inner_type.non_null?, ast_node)
+                  if HALT != continue_value
+                    continue_field(next_path, continue_value, field, inner_type, ast_node, next_selections, false, owner_object, arguments)
+                  end
                 end
               end
+            rescue NoMethodError
+              # This happens when the GraphQL schema doesn't match the implementation. Help the dev debug.
+              raise ListResultFailedError.new(value: value, field: field, path: path)
             end
+
             response_list
           when "NON_NULL"
             inner_type = type.of_type

data/lib/graphql/interface_type.rb

@@ -5,6 +5,7 @@ module GraphQL
     accepts_definitions :fields, :orphan_types, :resolve_type, field: GraphQL::Define::AssignObjectField
 
     attr_accessor :fields, :orphan_types, :resolve_type_proc
+    attr_writer :type_membership_class  
     ensure_defined :fields, :orphan_types, :resolve_type_proc, :resolve_type
 
     def initialize
@@ -61,5 +62,9 @@ module GraphQL
       type_name = type.is_a?(String) ? type : type.graphql_name
       !get_possible_type(type_name, ctx).nil?
     end
+
+    def type_membership_class
+      @type_membership_class || GraphQL::Schema::TypeMembership
+    end
   end
 end

data/lib/graphql/language/nodes.rb

@@ -39,11 +39,11 @@ module GraphQL
 
         # Value equality
         # @return [Boolean] True if `self` is equivalent to `other`
-        def eql?(other)
+        def ==(other)
           return true if equal?(other)
-          other.is_a?(self.class) &&
-            other.scalars.eql?(self.scalars) &&
-            other.children.eql?(self.children)
+          other.kind_of?(self.class) &&
+            other.scalars == self.scalars &&
+            other.children == self.children
         end
 
         NO_CHILDREN = [].freeze

data/lib/graphql/object_type.rb

@@ -17,17 +17,15 @@ module GraphQL
     def initialize
       super
       @fields = {}
-      @interface_fields = {}
-      @dirty_interfaces = []
-      @dirty_inherited_interfaces = []
+      @clean_inherited_fields = nil
+      @structural_interface_type_memberships = []
+      @inherited_interface_type_memberships = []
     end
 
     def initialize_copy(other)
       super
-      @clean_interfaces = nil
-      @clean_inherited_interfaces = nil
-      @dirty_interfaces = other.dirty_interfaces.dup
-      @dirty_inherited_interfaces = other.dirty_inherited_interfaces.dup
+      @structural_interface_type_memberships = other.structural_interface_type_memberships.dup
+      @inherited_interface_type_memberships = other.inherited_interface_type_memberships.dup
       @fields = other.fields.dup
     end
 
@@ -35,18 +33,27 @@ module GraphQL
     # @param new_interfaces [Array<GraphQL::Interface>] interfaces that this type implements
     # @deprecated Use `implements` instead of `interfaces`.
     def interfaces=(new_interfaces)
-      @clean_interfaces = nil
-      @clean_inherited_interfaces = nil
+      @structural_interface_type_memberships = []
+      @inherited_interface_type_memberships = []
       @clean_inherited_fields = nil
-
-      @dirty_inherited_interfaces = []
-      @dirty_inherited_fields = {}
       implements(new_interfaces, inherit: true)
     end
 
-    def interfaces
-      load_interfaces
-      @clean_interfaces
+    def interfaces(ctx = GraphQL::Query::NullContext)
+      ensure_defined
+      visible_ifaces = []
+      unfiltered = ctx == GraphQL::Query::NullContext
+      [@structural_interface_type_memberships, @inherited_interface_type_memberships].each do |tms|
+        tms.each do |type_membership|
+          if unfiltered || type_membership.visible?(ctx)
+            # if this is derived from a class-based object, we have to
+            # get the `.graphql_definition` of the attached interface.
+            visible_ifaces << GraphQL::BaseType.resolve_related_type(type_membership.abstract_type)
+          end
+        end
+      end
+
+      visible_ifaces
     end
 
     def kind
@@ -71,24 +78,30 @@ module GraphQL
     # This declaration will be validated when the schema is defined.
     # @param interfaces [Array<GraphQL::Interface>] add a new interface that this type implements
     # @param inherits [Boolean] If true, copy the interfaces' field definitions to this type
-    def implements(interfaces, inherit: false)
+    def implements(interfaces, inherit: false, **options)
       if !interfaces.is_a?(Array)
         raise ArgumentError, "`implements(interfaces)` must be an array, not #{interfaces.class} (#{interfaces})"
       end
-
-      @clean_interfaces = nil
       @clean_inherited_fields = nil
-      dirty_ifaces = inherit ? @dirty_inherited_interfaces : @dirty_interfaces
-      dirty_ifaces.concat(interfaces)
+
+      type_memberships = inherit ? @inherited_interface_type_memberships : @structural_interface_type_memberships
+      interfaces.each do |iface|
+        iface = BaseType.resolve_related_type(iface)
+        if iface.is_a?(GraphQL::InterfaceType)
+          type_memberships << iface.type_membership_class.new(iface, self, options)
+        end
+      end
     end
 
     def resolve_type_proc
       nil
     end
 
+    attr_writer :structural_interface_type_memberships
+
     protected
 
-    attr_reader :dirty_interfaces, :dirty_inherited_interfaces
+    attr_reader :structural_interface_type_memberships, :inherited_interface_type_memberships
 
     private
 
@@ -97,24 +110,20 @@ module GraphQL
     end
 
     def interface_fields
-      load_interfaces
-      @clean_inherited_fields
-    end
-
-    def load_interfaces
-      @clean_interfaces ||= begin
+      if @clean_inherited_fields
+        @clean_inherited_fields
+      else
         ensure_defined
-        clean_ifaces = normalize_interfaces(@dirty_interfaces)
-        clean_inherited_ifaces = normalize_interfaces(@dirty_inherited_interfaces)
-        inherited_fields = {}
-        clean_inherited_ifaces.each do |iface|
-          # This will be found later in schema validation:
+        @clean_inherited_fields = {}
+        @inherited_interface_type_memberships.each do |type_membership|
+          iface = GraphQL::BaseType.resolve_related_type(type_membership.abstract_type)
           if iface.is_a?(GraphQL::InterfaceType)
-            inherited_fields.merge!(iface.fields)
+            @clean_inherited_fields.merge!(iface.fields)
+          else
+            pp iface
           end
         end
-        @clean_inherited_fields = inherited_fields
-        clean_inherited_ifaces + clean_ifaces
+        @clean_inherited_fields
       end
     end
   end

data/lib/graphql/pagination/connection.rb

@@ -54,19 +54,39 @@ module GraphQL
       # @param last [Integer, nil] Limit parameter from the client, if provided
       # @param before [String, nil] A cursor for pagination, if the client provided one.
       # @param max_page_size [Integer, nil] A configured value to cap the result size. Applied as `first` if neither first or last are given.
-      def initialize(items, context: nil, first: nil, after: nil, max_page_size: nil, last: nil, before: nil)
+      def initialize(items, context: nil, first: nil, after: nil, max_page_size: :not_given, last: nil, before: nil)
         @items = items
         @context = context
         @first_value = first
         @after_value = after
         @last_value = last
         @before_value = before
-        @max_page_size = max_page_size
+
+        # This is only true if the object was _initialized_ with an override
+        # or if one is assigned later.
+        @has_max_page_size_override = max_page_size != :not_given
+        @max_page_size = if max_page_size == :not_given
+          nil
+        else
+          max_page_size
+        end
+      end
+
+      def max_page_size=(new_value)
+        @has_max_page_size_override = true
+        @max_page_size = new_value
       end
 
-      attr_writer :max_page_size
       def max_page_size
-        @max_page_size ||= context.schema.default_max_page_size
+        if @has_max_page_size_override
+          @max_page_size
+        else
+          context.schema.default_max_page_size
+        end
+      end
+
+      def has_max_page_size_override?
+        @has_max_page_size_override
       end
 
       attr_writer :first