graphql 2.4.3 → 2.5.0

data/lib/graphql/schema/subscription.rb

@@ -19,13 +19,22 @@ module GraphQL
       # propagate null.
       null false
 
+      # @api private
       def initialize(object:, context:, field:)
         super
         # Figure out whether this is an update or an initial subscription
         @mode = context.query.subscription_update? ? :update : :subscribe
+        @subscription_written = false
+        @original_arguments = nil
+        if (subs_ns = context.namespace(:subscriptions)) &&
+          (sub_insts = subs_ns[:subscriptions])
+          sub_insts[context.current_path] = self
+        end
       end
 
+      # @api private
       def resolve_with_support(**args)
+        @original_arguments = args # before `loads:` have been run
         result = nil
         unsubscribed = true
         unsubscribed_result = catch :graphql_subscription_unsubscribed do
@@ -46,7 +55,9 @@ module GraphQL
         end
       end
 
-      # Implement the {Resolve} API
+      # Implement the {Resolve} API.
+      # You can implement this if you want code to run for _both_ the initial subscription
+      # and for later updates. Or, implement {#subscribe} and {#update}
       def resolve(**args)
         # Dispatch based on `@mode`, which will raise a `NoMethodError` if we ever
         # have an unexpected `@mode`
@@ -54,8 +65,9 @@ module GraphQL
       end
 
       # Wrap the user-defined `#subscribe` hook
+      # @api private
       def resolve_subscribe(**args)
-        ret_val = args.any? ? subscribe(**args) : subscribe
+        ret_val = !args.empty? ? subscribe(**args) : subscribe
         if ret_val == :no_response
           context.skip
         else
@@ -71,8 +83,9 @@ module GraphQL
       end
 
       # Wrap the user-provided `#update` hook
+      # @api private
       def resolve_update(**args)
-        ret_val = args.any? ? update(**args) : update
+        ret_val = !args.empty? ? update(**args) : update
         if ret_val == NO_UPDATE
           context.namespace(:subscriptions)[:no_update] = true
           context.skip
@@ -106,14 +119,13 @@ module GraphQL
         throw :graphql_subscription_unsubscribed, update_value
       end
 
-      READING_SCOPE = ::Object.new
       # Call this method to provide a new subscription_scope; OR
       # call it without an argument to get the subscription_scope
       # @param new_scope [Symbol]
       # @param optional [Boolean] If true, then don't require `scope:` to be provided to updates to this subscription.
       # @return [Symbol]
-      def self.subscription_scope(new_scope = READING_SCOPE, optional: false)
-        if new_scope != READING_SCOPE
+      def self.subscription_scope(new_scope = NOT_CONFIGURED, optional: false)
+        if new_scope != NOT_CONFIGURED
           @subscription_scope = new_scope
           @subscription_scope_optional = optional
         elsif defined?(@subscription_scope)
@@ -150,6 +162,40 @@ module GraphQL
       def self.topic_for(arguments:, field:, scope:)
         Subscriptions::Serialize.dump_recursive([scope, field.graphql_name, arguments])
       end
+
+      # Calls through to `schema.subscriptions` to register this subscription with the backend.
+      # This is automatically called by GraphQL-Ruby after a query finishes successfully,
+      # but if you need to commit the subscription during `#subscribe`, you can call it there.
+      # (This method also sets a flag showing that this subscription was already written.)
+      #
+      # If you call this method yourself, you may also need to {#unsubscribe}
+      # or call `subscriptions.delete_subscription` to clean up the database if the query crashes with an error
+      # later in execution.
+      # @return [void]
+      def write_subscription
+        if subscription_written?
+          raise GraphQL::Error, "`write_subscription` was called but `#{self.class}#subscription_written?` is already true. Remove a call to `write subscription`."
+        else
+          @subscription_written = true
+          context.schema.subscriptions.write_subscription(context.query, [event])
+        end
+        nil
+      end
+
+      # @return [Boolean] `true` if {#write_subscription} was called already
+      def subscription_written?
+        @subscription_written
+      end
+
+      # @return [Subscriptions::Event] This object is used as a representation of this subscription for the backend
+      def event
+        @event ||= Subscriptions::Event.new(
+          name: field.name,
+          arguments: @original_arguments,
+          context: context,
+          field: field,
+        )
+      end
     end
   end
 end

data/lib/graphql/schema/union.rb

@@ -11,7 +11,7 @@ module GraphQL
         end
 
         def possible_types(*types, context: GraphQL::Query::NullContext.instance, **options)
-          if types.any?
+          if !types.empty?
             types.each do |t|
               assert_valid_union_member(t)
               type_memberships << type_membership_class.new(self, t, **options)

data/lib/graphql/schema/validator/required_validator.rb

@@ -51,19 +51,36 @@ module GraphQL
         end
 
         def validate(_object, context, value)
-          matched_conditions = 0
+          fully_matched_conditions = 0
+          partially_matched_conditions = 0
 
           if !value.nil?
             @one_of.each do |one_of_condition|
               case one_of_condition
               when Symbol
                 if value.key?(one_of_condition)
-                  matched_conditions += 1
+                  fully_matched_conditions += 1
                 end
               when Array
-                if one_of_condition.all? { |k| value.key?(k) }
-                  matched_conditions += 1
-                  break
+                any_match = false
+                full_match = true
+
+                one_of_condition.each do |k|
+                  if value.key?(k)
+                    any_match = true
+                  else
+                    full_match = false
+                  end
+                end
+
+                partial_match = !full_match && any_match
+
+                if full_match
+                  fully_matched_conditions += 1
+                end
+
+                if partial_match
+                  partially_matched_conditions += 1
                 end
               else
                 raise ArgumentError, "Unknown one_of condition: #{one_of_condition.inspect}"
@@ -71,7 +88,7 @@ module GraphQL
             end
           end
 
-          if matched_conditions == 1
+          if fully_matched_conditions == 1 && partially_matched_conditions == 0
             nil # OK
           else
             @message || build_message(context)

data/lib/graphql/schema/validator.rb

@@ -143,7 +143,7 @@ module GraphQL
           end
         end
 
-        if all_errors.any?
+        if !all_errors.empty?
           raise ValidationFailedError.new(errors: all_errors)
         end
         nil

data/lib/graphql/schema/visibility/migration.rb

@@ -112,6 +112,7 @@ module GraphQL
           :all_types_h,
           :fields,
           :loadable?,
+          :loadable_possible_types,
           :type,
           :arguments,
           :argument,

data/lib/graphql/schema/visibility/profile.rb

@@ -18,7 +18,7 @@ module GraphQL
           if ctx.respond_to?(:types) && (types = ctx.types).is_a?(self)
             types
           else
-            schema.visibility.profile_for(ctx, nil)
+            schema.visibility.profile_for(ctx)
           end
         end
 
@@ -38,38 +38,17 @@ module GraphQL
           @all_types = {}
           @all_types_loaded = false
           @unvisited_types = []
-          @referenced_types = Hash.new { |h, type_defn| h[type_defn] = [] }.compare_by_identity
-          @cached_directives = {}
           @all_directives = nil
-          @cached_visible = Hash.new { |h, member|
-            h[member] = @schema.visible?(member, @context)
-          }.compare_by_identity
+          @cached_visible = Hash.new { |h, member| h[member] = @schema.visible?(member, @context) }.compare_by_identity
 
           @cached_visible_fields = Hash.new { |h, owner|
             h[owner] = Hash.new do |h2, field|
-              h2[field] = if @cached_visible[field] &&
-                  (ret_type = field.type.unwrap) &&
-                  @cached_visible[ret_type] &&
-                  (owner == field.owner || (!owner.kind.object?) || field_on_visible_interface?(field, owner))
-
-                if !field.introspection?
-                  # The problem is that some introspection fields may have references
-                  # to non-custom introspection types.
-                  # If those were added here, they'd cause a DuplicateNamesError.
-                  # This is basically a bug -- those fields _should_ reference the custom types.
-                  add_type(ret_type, field)
-                end
-                true
-              else
-                false
-              end
+              h2[field] = visible_field_for(owner, field)
             end.compare_by_identity
           }.compare_by_identity
 
           @cached_visible_arguments = Hash.new do |h, arg|
             h[arg] = if @cached_visible[arg] && (arg_type = arg.type.unwrap) && @cached_visible[arg_type]
-              add_type(arg_type, arg)
-              arg.validate_default_value
               true
             else
               false
@@ -88,39 +67,7 @@ module GraphQL
             end
           end.compare_by_identity
 
-          @cached_possible_types = Hash.new do |h, type|
-            h[type] = case type.kind.name
-            when "INTERFACE"
-              load_all_types
-              pts = []
-              @unfiltered_interface_type_memberships[type].each { |itm|
-                if @cached_visible[itm] && (ot = itm.object_type) && @cached_visible[ot] && referenced?(ot)
-                  pts << ot
-                end
-              }
-              pts
-            when "UNION"
-              pts = []
-              type.type_memberships.each { |tm|
-                if @cached_visible[tm] &&
-                    (ot = tm.object_type) &&
-                    @cached_visible[ot] &&
-                    referenced?(ot)
-                  pts << ot
-                end
-              }
-              pts
-            when "OBJECT"
-              load_all_types
-              if @all_types[type.graphql_name] == type
-                [type]
-              else
-                EmptyObjects::EMPTY_ARRAY
-              end
-            else
-              GraphQL::EmptyObjects::EMPTY_ARRAY
-            end
-          end.compare_by_identity
+          @cached_possible_types = Hash.new { |h, type| h[type] = possible_types_for(type) }.compare_by_identity
 
           @cached_enum_values = Hash.new do |h, enum_t|
             values = non_duplicate_items(enum_t.enum_values(@context), @cached_visible)
@@ -137,6 +84,8 @@ module GraphQL
           @cached_arguments = Hash.new do |h, owner|
             h[owner] = non_duplicate_items(owner.all_argument_definitions, @cached_visible_arguments)
           end.compare_by_identity
+
+          @loadable_possible_types = Hash.new { |h, union_type| h[union_type] = union_type.possible_types }.compare_by_identity
         end
 
         def field_on_visible_interface?(field, owner)
@@ -164,17 +113,12 @@ module GraphQL
         end
 
         def type(type_name)
-          t = if (loaded_t = @all_types[type_name])
-            loaded_t
-          elsif !@all_types_loaded
-            load_all_types
-            @all_types[type_name]
-          end
+          t = @schema.visibility.get_type(type_name) # rubocop:disable Development/ContextIsPassedCop
           if t
             if t.is_a?(Array)
               vis_t = nil
               t.each do |t_defn|
-                if @cached_visible[t_defn]
+                if @cached_visible[t_defn] && referenced?(t_defn)
                   if vis_t.nil?
                     vis_t = t_defn
                   else
@@ -184,7 +128,7 @@ module GraphQL
               end
               vis_t
             else
-              if t && @cached_visible[t]
+              if t && @cached_visible[t] && referenced?(t)
                 t
               else
                 nil
@@ -215,7 +159,7 @@ module GraphQL
                 end
               end
             end
-            visible_f.ensure_loaded
+            visible_f&.ensure_loaded
           elsif f && @cached_visible_fields[owner][f.ensure_loaded]
             f
           else
@@ -267,15 +211,15 @@ module GraphQL
         end
 
         def query_root
-          add_if_visible(@schema.query)
+          ((t = @schema.query) && @cached_visible[t]) ? t : nil
         end
 
         def mutation_root
-          add_if_visible(@schema.mutation)
+          ((t = @schema.mutation) && @cached_visible[t]) ? t : nil
         end
 
         def subscription_root
-          add_if_visible(@schema.subscription)
+          ((t = @schema.subscription) && @cached_visible[t]) ? t : nil
         end
 
         def all_types
@@ -293,38 +237,31 @@ module GraphQL
         end
 
         def directive_exists?(dir_name)
-          if (dir = @schema.directives[dir_name]) && @cached_visible[dir]
-            !!dir
-          else
-            load_all_types
-            !!@cached_directives[dir_name]
-          end
+          directives.any? { |d| d.graphql_name == dir_name }
         end
 
         def directives
-          @all_directives ||= begin
-            load_all_types
-            dirs = []
-            @schema.directives.each do |name, dir_defn|
-              if !@cached_directives[name] && @cached_visible[dir_defn]
-                dirs << dir_defn
-              end
-            end
-            dirs.concat(@cached_directives.values)
-          end
+          @all_directives ||= @schema.visibility.all_directives.select { |dir|
+            @cached_visible[dir] && @schema.visibility.all_references[dir].any? { |ref| ref == true || (@cached_visible[ref] && referenced?(ref)) }
+          }
         end
 
         def loadable?(t, _ctx)
+          load_all_types
           !@all_types[t.graphql_name] && @cached_visible[t]
         end
 
+        def loadable_possible_types(t, _ctx)
+          @loadable_possible_types[t]
+        end
+
         def loaded_types
           @all_types.values
         end
 
-        def reachable_type?(name)
+        def reachable_type?(type_name)
           load_all_types
-          !!@all_types[name]
+          !!@all_types[type_name]
         end
 
         def visible_enum_value?(enum_value, _ctx = nil)
@@ -333,29 +270,6 @@ module GraphQL
 
         private
 
-        def add_if_visible(t)
-          (t && @cached_visible[t]) ? (add_type(t, true); t) : nil
-        end
-
-        def add_type(t, by_member)
-          if t && @cached_visible[t]
-            n = t.graphql_name
-            if (prev_t = @all_types[n])
-              if !prev_t.equal?(t)
-                raise_duplicate_definition(prev_t, t)
-              end
-              false
-            else
-              @referenced_types[t] << by_member
-              @all_types[n] = t
-              @unvisited_types << t
-              true
-            end
-          else
-            false
-          end
-        end
-
         def non_duplicate_items(definitions, visibility_cache)
           non_dups = []
           definitions.each do |defn|
@@ -373,153 +287,71 @@ module GraphQL
           raise DuplicateNamesError.new(duplicated_name: first_defn.path, duplicated_definition_1: first_defn.inspect, duplicated_definition_2: second_defn.inspect)
         end
 
-        def referenced?(t)
-          load_all_types
-          @referenced_types[t].any? { |reference| (reference == true) || @cached_visible[reference] }
-        end
-
         def load_all_types
           return if @all_types_loaded
           @all_types_loaded = true
-          entry_point_types = [
-            query_root,
-            mutation_root,
-            subscription_root,
-            *@schema.introspection_system.types.values,
-          ]
-
-          # Don't include any orphan_types whose interfaces aren't visible.
-          @schema.orphan_types.each do |orphan_type|
-            if @cached_visible[orphan_type] &&
-              orphan_type.interface_type_memberships.any? { |tm| @cached_visible[tm] && @cached_visible[tm.abstract_type] }
-              entry_point_types << orphan_type
-            end
-          end
-
-          @schema.directives.each do |_dir_name, dir_class|
-            if @cached_visible[dir_class]
-              arguments(dir_class).each do |arg|
-                entry_point_types << arg.type.unwrap
-              end
-            end
-          end
-
-          entry_point_types.compact! # Root types might be nil
-          entry_point_types.flatten! # handle multiple defns
-          entry_point_types.each { |t| add_type(t, true) }
-
-          @unfiltered_interface_type_memberships = Hash.new { |h, k| h[k] = [] }.compare_by_identity
-          @add_possible_types = Set.new
-          @late_types = []
-
-          while @unvisited_types.any? || @late_types.any?
-            while t = @unvisited_types.pop
-              # These have already been checked for `.visible?`
-              visit_type(t)
-            end
-            @add_possible_types.each do |int_t|
-              itms = @unfiltered_interface_type_memberships[int_t]
-              itms.each do |itm|
-                if @cached_visible[itm] && (obj_type = itm.object_type) && @cached_visible[obj_type]
-                  add_type(obj_type, itm)
+          visit = Visibility::Visit.new(@schema) do |member|
+            if member.is_a?(Module) && member.respond_to?(:kind)
+              if @cached_visible[member]
+                type_name = member.graphql_name
+                if (prev_t = @all_types[type_name]) && !prev_t.equal?(member)
+                  raise_duplicate_definition(member, prev_t)
                 end
+                @all_types[type_name] = member
+                true
+              else
+                false
               end
-            end
-            @add_possible_types.clear
-
-            while (union_tm = @late_types.shift)
-              late_obj_t = union_tm.object_type
-              obj_t = @all_types[late_obj_t.graphql_name] || raise("Failed to resolve #{late_obj_t.graphql_name.inspect} from #{union_tm.inspect}")
-              union_tm.abstract_type.assign_type_membership_object_type(obj_t)
+            else
+              @cached_visible[member]
             end
           end
-
+          visit.visit_each
           @all_types.delete_if { |type_name, type_defn| !referenced?(type_defn) }
           nil
         end
 
-        def visit_type(type)
-          visit_directives(type)
-          case type.kind.name
-          when "OBJECT", "INTERFACE"
-            if type.kind.object?
-              type.interface_type_memberships.each do |itm|
-                @unfiltered_interface_type_memberships[itm.abstract_type] << itm
-              end
-              # recurse into visible implemented interfaces
-              interfaces(type).each do |interface|
-                add_type(interface, type)
-              end
-            else
-              type.orphan_types.each { |t| add_type(t, type)}
-            end
-
-            # recurse into visible fields
-            t_f = type.all_field_definitions
-            t_f.each do |field|
-              field.ensure_loaded
-              if @cached_visible[field]
-                visit_directives(field)
-                field_type = field.type.unwrap
-                if field_type.kind.interface?
-                  @add_possible_types.add(field_type)
-                end
-                add_type(field_type, field)
+        def referenced?(type_defn)
+          @schema.visibility.all_references[type_defn].any? { |r| r == true ||  @cached_visible[r] }
+        end
 
-                # recurse into visible arguments
-                arguments(field).each do |argument|
-                  visit_directives(argument)
-                  add_type(argument.type.unwrap, argument)
-                end
+        def possible_types_for(type)
+          case type.kind.name
+          when "INTERFACE"
+            pts = []
+            @schema.visibility.all_interface_type_memberships[type].each do |(itm, impl_type)|
+              if @cached_visible[itm] && @cached_visible[impl_type] && referenced?(impl_type)
+                pts << impl_type
               end
             end
-          when "INPUT_OBJECT"
-            # recurse into visible arguments
-            arguments(type).each do |argument|
-              visit_directives(argument)
-              add_type(argument.type.unwrap, argument)
-            end
+            pts
           when "UNION"
-            # recurse into visible possible types
-            type.type_memberships.each do |tm|
-              if @cached_visible[tm]
-                obj_t = tm.object_type
-                if obj_t.is_a?(GraphQL::Schema::LateBoundType)
-                  @late_types << tm
-                else
-                  if obj_t.is_a?(String)
-                    obj_t = Member::BuildType.constantize(obj_t)
-                    tm.object_type = obj_t
-                  end
-                  if @cached_visible[obj_t]
-                    add_type(obj_t, tm)
-                  end
-                end
+            pts = []
+            type.type_memberships.each { |tm|
+              if @cached_visible[tm] &&
+                  (ot = tm.object_type) &&
+                  @cached_visible[ot] &&
+                  referenced?(ot)
+                pts << ot
               end
+            }
+            pts
+          when "OBJECT"
+            if @cached_visible[type]
+              [type]
+            else
+              EmptyObjects::EMPTY_ARRAY
             end
-          when "ENUM"
-            enum_values(type).each do |val|
-              visit_directives(val)
-            end
-          when "SCALAR"
-            # pass
+          else
+            GraphQL::EmptyObjects::EMPTY_ARRAY
           end
         end
 
-        def visit_directives(member)
-          member.directives.each { |dir|
-            dir_class = dir.class
-            if @cached_visible[dir_class]
-              dir_name = dir_class.graphql_name
-              if (existing_dir = @cached_directives[dir_name])
-                if existing_dir != dir_class
-                  raise ArgumentError, "Two directives for `@#{dir_name}`: #{existing_dir}, #{dir.class}"
-                end
-              else
-                @cached_directives[dir.graphql_name] = dir_class
-              end
-            end
-          }
+        def visible_field_for(owner, field)
+          @cached_visible[field] &&
+            (ret_type = field.type.unwrap) &&
+            @cached_visible[ret_type] &&
+            (owner == field.owner || (!owner.kind.object?) || field_on_visible_interface?(field, owner))
         end
       end
     end