graphql 1.10.5 → 1.10.6

data/lib/graphql/schema/field/connection_extension.rb

@@ -35,7 +35,9 @@ module GraphQL
             value.after_value ||= arguments[:after]
             value.last_value ||= arguments[:last]
             value.before_value ||= arguments[:before]
-            value.max_page_size ||= field.max_page_size
+            if field.has_max_page_size? && !value.has_max_page_size_override?
+              value.max_page_size = field.max_page_size
+            end
             value
           elsif context.schema.new_connections?
             wrappers = context.namespace(:connections)[:all_wrappers] ||= context.schema.connections.all_wrappers

data/lib/graphql/schema/input_object.rb

@@ -21,6 +21,7 @@ module GraphQL
         end
         # Apply prepares, not great to have it duplicated here.
         @arguments_by_keyword = {}
+        maybe_lazies = []
         self.class.arguments.each do |name, arg_defn|
           @arguments_by_keyword[arg_defn.keyword] = arg_defn
           ruby_kwargs_key = arg_defn.keyword
@@ -31,11 +32,14 @@ module GraphQL
             # With the interpreter, it's done during `coerce_arguments`
             if loads && !arg_defn.from_resolver? && !context.interpreter?
               value = @ruby_style_hash[ruby_kwargs_key]
-              @ruby_style_hash[ruby_kwargs_key] = if arg_defn.type.list?
+              loaded_value = if arg_defn.type.list?
                 value.map { |val| load_application_object(arg_defn, loads, val, context) }
               else
                 load_application_object(arg_defn, loads, value, context)
               end
+              maybe_lazies << context.schema.after_lazy(loaded_value) do |loaded_value|
+                @ruby_style_hash[ruby_kwargs_key] = loaded_value
+              end
             end
 
             # Weirdly, procs are applied during coercion, but not methods.
@@ -45,6 +49,8 @@ module GraphQL
             end
           end
         end
+
+        @maybe_lazies = maybe_lazies
       end
 
       # @return [GraphQL::Query::Context] The context for this query
@@ -67,7 +73,13 @@ module GraphQL
       end
 
       def prepare
-        self
+        if context
+          context.schema.after_any_lazies(@maybe_lazies) do
+            self
+          end
+        else
+          self
+        end
       end
 
       def unwrap_value(value)

data/lib/graphql/schema/interface.rb

@@ -37,6 +37,14 @@ module GraphQL
           false
         end
 
+        def type_membership_class(membership_class = nil)
+          if membership_class
+            @type_membership_class = membership_class
+          else
+            @type_membership_class || find_inherited_value(:type_membership_class, GraphQL::Schema::TypeMembership)
+          end
+        end
+
         # Here's the tricky part. Make sure behavior keeps making its way down the inheritance chain.
         def included(child_class)
           if !child_class.is_a?(Class)
@@ -46,6 +54,7 @@ module GraphQL
             # We need this before we can call `own_interfaces`
             child_class.extend(Schema::Interface::DefinitionMethods)
 
+            child_class.type_membership_class(self.type_membership_class)
             child_class.own_interfaces << self
             child_class.interfaces.reverse_each do |interface_defn|
               child_class.extend(interface_defn::DefinitionMethods)
@@ -91,6 +100,7 @@ module GraphQL
           type_defn.name = graphql_name
           type_defn.description = description
           type_defn.orphan_types = orphan_types
+          type_defn.type_membership_class = self.type_membership_class
           type_defn.ast_node = ast_node
           fields.each do |field_name, field_inst|
             field_defn = field_inst.graphql_definition

data/lib/graphql/schema/loader.rb

@@ -21,7 +21,7 @@ module GraphQL
         schema.fetch("types").each do |type|
           next if type.fetch("name").start_with?("__")
           type_object = define_type(type, type_resolver)
-          types[type_object.name] = type_object
+          types[type["name"]] = type_object
         end
 
         kargs = { orphan_types: types.values, resolve_type: NullResolveType }

data/lib/graphql/schema/member/has_arguments.rb

@@ -71,7 +71,8 @@ module GraphQL
           # Cache this hash to avoid re-merging it
           arg_defns = self.arguments
 
-          arg_defns.each do |arg_name, arg_defn|
+          maybe_lazies = []
+          arg_lazies = arg_defns.map do |arg_name, arg_defn|
             arg_key = arg_defn.keyword
             has_value = false
             if values.key?(arg_name)
@@ -96,20 +97,28 @@ module GraphQL
                 end
               end
 
-              prepared_value = context.schema.error_handler.with_error_handling(context) do
+              context.schema.after_lazy(loaded_value) do |loaded_value|
+                coerced_value = nil
+                prepared_value = context.schema.error_handler.with_error_handling(context) do
 
-                coerced_value = if loaded_value
-                  loaded_value
-                else
-                  arg_defn.type.coerce_input(value, context)
+                  coerced_value = if loaded_value
+                    loaded_value
+                  else
+                    arg_defn.type.coerce_input(value, context)
+                  end
+
+                  arg_defn.prepare_value(parent_object, coerced_value, context: context)
                 end
 
-                arg_defn.prepare_value(parent_object, coerced_value, context: context)
+                kwarg_arguments[arg_defn.keyword] = prepared_value
               end
-              kwarg_arguments[arg_defn.keyword] = prepared_value
             end
           end
-          kwarg_arguments
+
+          maybe_lazies.concat(arg_lazies)
+          context.schema.after_any_lazies(maybe_lazies) do
+            kwarg_arguments
+          end
         end
 
         module ArgumentClassAccessor
@@ -138,6 +147,9 @@ module GraphQL
 
           def load_application_object(argument, lookup_as_type, id, context)
             # See if any object can be found for this ID
+            if id.nil?
+              return nil
+            end
             loaded_application_object = object_from_id(lookup_as_type, id, context)
             context.schema.after_lazy(loaded_application_object) do |application_object|
               if application_object.nil?

data/lib/graphql/schema/object.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "graphql/query/null_context"
+
 module GraphQL
   class Schema
     class Object < GraphQL::Schema::Member
@@ -69,47 +71,81 @@ module GraphQL
       end
 
       class << self
-        def implements(*new_interfaces)
+        def implements(*new_interfaces, **options)
+          new_memberships = []
           new_interfaces.each do |int|
             if int.is_a?(Module)
               unless int.include?(GraphQL::Schema::Interface)
                 raise "#{int} cannot be implemented since it's not a GraphQL Interface. Use `include` for plain Ruby modules."
               end
 
+              new_memberships << int.type_membership_class.new(int, self, options)
+
               # Include the methods here,
               # `.fields` will use the inheritance chain
               # to find inherited fields
               include(int)
+            elsif int.is_a?(GraphQL::InterfaceType)
+              new_memberships << int.type_membership_class.new(int, self, options)
+            elsif int.is_a?(String) || int.is_a?(GraphQL::Schema::LateBoundType)
+              if options.any?
+                raise ArgumentError, "`implements(...)` doesn't support options with late-loaded types yet. Remove #{options} and open an issue to request this feature."
+              end
+              new_memberships << int
+            else
+              raise ArgumentError, "Unexpected interface definition (expected module): #{int} (#{int.class})"
             end
           end
+
           # Remove any interfaces which are being replaced (late-bound types are updated in place this way)
-          own_interfaces.reject! { |i|
-            new_interfaces.any? { |new_i|
-              new_name = new_i.is_a?(String) ? new_i : new_i.graphql_name
-              old_name = i.is_a?(String) ? i : i.graphql_name
+          own_interface_type_memberships.reject! { |old_i_m|
+            old_int_type = old_i_m.respond_to?(:abstract_type) ? old_i_m.abstract_type : old_i_m
+            old_name = Schema::Member::BuildType.to_type_name(old_int_type)
+
+            new_memberships.any? { |new_i_m|
+              new_int_type = new_i_m.respond_to?(:abstract_type) ? new_i_m.abstract_type : new_i_m
+              new_name = Schema::Member::BuildType.to_type_name(new_int_type)
+
               new_name == old_name
             }
           }
-          own_interfaces.concat(new_interfaces)
+          own_interface_type_memberships.concat(new_memberships)
         end
 
-        def interfaces
-          inherited_interfaces = (superclass.respond_to?(:interfaces) ? superclass.interfaces : nil)
-          if inherited_interfaces && !inherited_interfaces.empty?
-            own_interfaces + inherited_interfaces
-          else
-            own_interfaces
-          end
+        def own_interface_type_memberships
+          @own_interface_type_memberships ||= []
+        end
+
+        def interface_type_memberships
+          own_interface_type_memberships + (superclass.respond_to?(:interface_type_memberships) ? superclass.interface_type_memberships : [])
         end
 
-        def own_interfaces
-          @own_interfaces ||= []
+        # param context [Query::Context] If omitted, skip filtering.
+        def interfaces(context = GraphQL::Query::NullContext)
+          visible_interfaces = []
+          unfiltered = context == GraphQL::Query::NullContext
+          own_interface_type_memberships.each do |type_membership|
+            # During initialization, `type_memberships` can hold late-bound types
+            case type_membership
+            when String, Schema::LateBoundType
+              visible_interfaces << type_membership
+            when Schema::TypeMembership
+              if unfiltered || type_membership.visible?(context)
+                visible_interfaces << type_membership.abstract_type
+              end
+            else
+              raise "Invariant: Unexpected type_membership #{type_membership.class}: #{type_membership.inspect}"
+            end
+          end
+          visible_interfaces + (superclass <= GraphQL::Schema::Object ? superclass.interfaces(context) : [])
         end
 
-        # Include legacy-style interfaces, too
+        # @return [Hash<String => GraphQL::Schema::Field>] All of this object's fields, indexed by name
+        # @see get_field A faster way to find one field by name ({#fields} merges hashes of inherited fields; {#get_field} just looks up one field.)
         def fields
           all_fields = super
           interfaces.each do |int|
+            # Include legacy-style interfaces, too
             if int.is_a?(GraphQL::InterfaceType)
               int_f = {}
               int.fields.each do |name, legacy_field|
@@ -126,7 +162,7 @@ module GraphQL
           obj_type = GraphQL::ObjectType.new
           obj_type.name = graphql_name
           obj_type.description = description
-          obj_type.interfaces = interfaces
+          obj_type.structural_interface_type_memberships = own_interface_type_memberships
           obj_type.introspection = introspection
           obj_type.mutation = mutation
           obj_type.ast_node = ast_node

data/lib/graphql/schema/possible_types.rb

@@ -14,9 +14,10 @@ module GraphQL
     class PossibleTypes
       def initialize(schema)
         @object_types = schema.types.values.select { |type| type.kind.object? }
-
-        @interface_implementers = Hash.new do |hash, key|
-          hash[key] = @object_types.select { |type| type.interfaces.include?(key) }.sort_by(&:name)
+        @interface_implementers = Hash.new do |h1, ctx|
+          h1[ctx] = Hash.new do |h2, int_type|
+            h2[int_type] = @object_types.select { |type| type.interfaces(ctx).include?(int_type) }.sort_by(&:name)
+          end
         end
       end
 
@@ -27,13 +28,17 @@ module GraphQL
         when GraphQL::UnionType
           type_defn.possible_types(ctx)
         when GraphQL::InterfaceType
-          @interface_implementers[type_defn]
+          interface_implementers(ctx, type_defn)
         when GraphQL::BaseType
           [type_defn]
         else
           raise "Unexpected possible_types object: #{type_defn.inspect}"
         end
       end
+
+      def interface_implementers(ctx, type_defn)
+        @interface_implementers[ctx][type_defn]
+      end
     end
   end
 end

data/lib/graphql/schema/warden.rb

@@ -95,7 +95,7 @@ module GraphQL
         @visible_parent_fields ||= read_through do |type|
           read_through do |f_name|
             field_defn = @schema.get_field(type, f_name)
-            if field_defn && visible_field?(field_defn)
+            if field_defn && visible_field?(type, field_defn)
               field_defn
             else
               nil
@@ -109,7 +109,8 @@ module GraphQL
       # @return [Array<GraphQL::BaseType>] The types which may be member of `type_defn`
       def possible_types(type_defn)
         @visible_possible_types ||= read_through { |type_defn|
-          @schema.possible_types(type_defn, @context).select { |t| visible_type?(t) }
+          pt = @schema.possible_types(type_defn, @context)
+          pt.select { |t| visible_type?(t) }
         }
         @visible_possible_types[type_defn]
       end
@@ -117,14 +118,14 @@ module GraphQL
       # @param type_defn [GraphQL::ObjectType, GraphQL::InterfaceType]
       # @return [Array<GraphQL::Field>] Fields on `type_defn`
       def fields(type_defn)
-        @visible_fields ||= read_through { |t| @schema.get_fields(t).each_value.select { |f| visible_field?(f) } }
+        @visible_fields ||= read_through { |t| @schema.get_fields(t).each_value.select { |f| visible_field?(t, f) } }
         @visible_fields[type_defn]
       end
 
       # @param argument_owner [GraphQL::Field, GraphQL::InputObjectType]
       # @return [Array<GraphQL::Argument>] Visible arguments on `argument_owner`
       def arguments(argument_owner)
-        @visible_arguments ||= read_through { |o| o.arguments.each_value.select { |a| visible_field?(a) } }
+        @visible_arguments ||= read_through { |o| o.arguments.each_value.select { |a| visible_argument?(a) } }
         @visible_arguments[argument_owner]
       end
 
@@ -136,7 +137,7 @@ module GraphQL
 
       # @return [Array<GraphQL::InterfaceType>] Visible interfaces implemented by `obj_type`
       def interfaces(obj_type)
-        @visible_interfaces ||= read_through { |t| t.interfaces.select { |i| visible?(i) } }
+        @visible_interfaces ||= read_through { |t| t.interfaces(@context).select { |i| visible?(i) } }
         @visible_interfaces[obj_type]
       end
 
@@ -160,8 +161,48 @@ module GraphQL
         @unions[obj_type]
       end
 
-      def visible_field?(field_defn)
-        visible?(field_defn) && visible_type?(field_defn.type.unwrap)
+      def visible_argument?(arg_defn)
+        visible?(arg_defn) && visible_type?(arg_defn.type.unwrap)
+      end
+
+      def visible_field?(owner_type, field_defn)
+        visible?(field_defn) && visible_type?(field_defn.type.unwrap) && field_on_visible_interface?(field_defn, owner_type)
+      end
+
+      # We need this to tell whether a field was inherited by an interface
+      # even when that interface is hidden from `#interfaces`
+      def unfiltered_interfaces(type_defn)
+        @unfiltered_interfaces ||= read_through(&:interfaces)
+        @unfiltered_interfaces[type_defn]
+      end
+
+      # If this field was inherited from an interface, and the field on that interface is _hidden_,
+      # then treat this inherited field as hidden.
+      # (If it _wasn't_ inherited, then don't hide it for this reason.)
+      def field_on_visible_interface?(field_defn, type_defn)
+        if type_defn.kind.object?
+          any_interface_has_field = false
+          any_interface_has_visible_field = false
+          ints = unfiltered_interfaces(type_defn)
+          ints.each do |interface_type|
+            if (iface_field_defn = interface_type.get_field(field_defn.graphql_name))
+              any_interface_has_field = true
+
+              if visible?(interface_type) && visible_field?(interface_type, iface_field_defn)
+                any_interface_has_visible_field = true
+              end
+            end
+          end
+
+          if any_interface_has_field
+            any_interface_has_visible_field
+          else
+            # it's the object's own field
+            true
+          end
+        else
+          true
+        end
       end
 
       def visible_type?(type_defn)

data/lib/graphql/types/big_int.rb

@@ -6,7 +6,7 @@ module GraphQL
       description "Represents non-fractional signed whole numeric values. Since the value may exceed the size of a 32-bit integer, it's encoded as a string."
 
       def self.coerce_input(value, _ctx)
-        Integer(value)
+        value && Integer(value)
       rescue ArgumentError
         nil
       end

data/lib/graphql/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql
 version: !ruby/object:Gem::Version
-  version: 1.10.5
+  version: 1.10.6
 platform: ruby
 authors:
 - Robert Mosolgo
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-03-12 00:00:00.000000000 Z
+date: 2020-04-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: benchmark-ips
@@ -500,6 +500,7 @@ files:
 - lib/graphql/query/arguments_cache.rb
 - lib/graphql/query/context.rb
 - lib/graphql/query/executor.rb
+- lib/graphql/query/fingerprint.rb
 - lib/graphql/query/input_validation_result.rb
 - lib/graphql/query/literal_input.rb
 - lib/graphql/query/null_context.rb