graphql 2.3.8 → 2.4.0

data/lib/graphql/schema/subset.rb

@@ -1,397 +0,0 @@
-# frozen_string_literal: true
-
-module GraphQL
-  class Schema
-    class Subset
-      def initialize(query)
-        @query = query
-        @context = query.context
-        @schema = query.schema
-        @all_types = {}
-        @all_types_loaded = false
-        @unvisited_types = []
-        @referenced_types = Hash.new { |h, type_defn| h[type_defn] = [] }.compare_by_identity
-        @cached_possible_types = nil
-        @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] &&
-                reachable_type?(ret_type.graphql_name) &&
-                (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
-          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)
-            true
-          else
-            false
-          end
-        end.compare_by_identity
-
-        @unfiltered_pt = Hash.new do |hash, type|
-          hash[type] = @schema.possible_types(type)
-        end.compare_by_identity
-      end
-
-      def field_on_visible_interface?(field, owner)
-        ints = owner.interface_type_memberships.map(&:abstract_type)
-        field_name = field.graphql_name
-        filtered_ints = interfaces(owner)
-        any_interface_has_field = false
-        any_interface_has_visible_field = false
-        ints.each do |int_t|
-          if (_int_f_defn = int_t.get_field(field_name, @context))
-            any_interface_has_field = true
-
-            if filtered_ints.include?(int_t) # TODO cycles, or maybe not necessary since previously checked? && @cached_visible_fields[owner][field]
-              any_interface_has_visible_field = true
-              break
-            end
-          end
-        end
-
-        if any_interface_has_field
-          any_interface_has_visible_field
-        else
-          true
-        end
-      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
-
-        if t
-          if t.is_a?(Array)
-            vis_t = nil
-            t.each do |t_defn|
-              if @cached_visible[t_defn]
-                if vis_t.nil?
-                  vis_t = t_defn
-                else
-                  raise_duplicate_definition(vis_t, t_defn)
-                end
-              end
-            end
-            vis_t
-          else
-            if t && @cached_visible[t]
-              t
-            else
-              nil
-            end
-          end
-        end
-      end
-
-      def field(owner, field_name)
-        f = if owner.kind.fields? && (field = owner.get_field(field_name, @context))
-          field
-        elsif owner == query_root && (entry_point_field = @schema.introspection_system.entry_point(name: field_name))
-          entry_point_field
-        elsif (dynamic_field = @schema.introspection_system.dynamic_field(name: field_name))
-          dynamic_field
-        else
-          nil
-        end
-        if f.is_a?(Array)
-          visible_f = nil
-          f.each do |f_defn|
-            if @cached_visible_fields[owner][f_defn]
-
-              if visible_f.nil?
-                visible_f = f_defn
-              else
-                raise_duplicate_definition(visible_f, f_defn)
-              end
-            end
-          end
-          visible_f
-        else
-          if f && @cached_visible_fields[owner][f]
-            f
-          else
-            nil
-          end
-        end
-      end
-
-      def fields(owner)
-        non_duplicate_items(owner.all_field_definitions, @cached_visible_fields[owner])
-      end
-
-      def arguments(owner)
-        non_duplicate_items(owner.all_argument_definitions, @cached_visible_arguments)
-      end
-
-      def argument(owner, arg_name)
-        # TODO this makes a Warden.visible_entry call down the stack
-        # I need a non-Warden implementation
-        arg = owner.get_argument(arg_name, @context)
-        if arg.is_a?(Array)
-          visible_arg = nil
-          arg.each do |arg_defn|
-            if @cached_visible_arguments[arg_defn]
-              if arg_defn&.loads
-                add_type(arg_defn.loads, arg_defn)
-              end
-              if visible_arg.nil?
-                visible_arg = arg_defn
-              else
-                raise_duplicate_definition(visible_arg, arg_defn)
-              end
-            end
-          end
-          visible_arg
-        else
-          if arg && @cached_visible_arguments[arg]
-            if arg&.loads
-              add_type(arg.loads, arg)
-            end
-            arg
-          else
-            nil
-          end
-        end
-      end
-
-      def possible_types(type)
-        @cached_possible_types ||= Hash.new do |h, type|
-          pt = case type.kind.name
-          when "INTERFACE"
-            # TODO this requires the global map
-            @unfiltered_pt[type]
-          when "UNION"
-            type.type_memberships.select { |tm| @cached_visible[tm] && @cached_visible[tm.object_type] }.map!(&:object_type)
-          else
-            [type]
-          end
-
-          # TODO use `select!` when possible, skip it for `[type]`
-          h[type] = pt.select { |t|
-            @cached_visible[t] && referenced?(t)
-          }
-        end.compare_by_identity
-        @cached_possible_types[type]
-      end
-
-      def interfaces(obj_or_int_type)
-        ints = obj_or_int_type.interface_type_memberships
-          .select { |itm| @cached_visible[itm] && @cached_visible[itm.abstract_type] }
-          .map!(&:abstract_type)
-        ints.uniq! # Remove any duplicate interfaces implemented via other interfaces
-        ints
-      end
-
-      def query_root
-        add_if_visible(@schema.query)
-      end
-
-      def mutation_root
-        add_if_visible(@schema.mutation)
-      end
-
-      def subscription_root
-        add_if_visible(@schema.subscription)
-      end
-
-      def all_types
-        @all_types_filtered ||= begin
-          load_all_types
-          at = []
-          @all_types.each do |_name, type_defn|
-            if possible_types(type_defn).any? || referenced?(type_defn)
-              at << type_defn
-            end
-          end
-          at
-        end
-      end
-
-      def enum_values(owner)
-        values = non_duplicate_items(owner.all_enum_value_definitions, @cached_visible)
-        if values.size == 0
-          raise GraphQL::Schema::Enum::MissingValuesError.new(owner)
-        end
-        values
-      end
-
-      def directive_exists?(dir_name)
-        dir = @schema.directives[dir_name]
-        dir && @cached_visible[dir]
-      end
-
-      def directives
-        @schema.directives.each_value.select { |d| @cached_visible[d] }
-      end
-
-      def loadable?(t, _ctx)
-        !@all_types[t.graphql_name] # TODO make sure t is not reachable but t is visible
-      end
-
-      # TODO rename this to indicate that it is called with a typename
-      def reachable_type?(type_name)
-        load_all_types
-        !!((t = @all_types[type_name]) && referenced?(t))
-      end
-
-      def loaded_types
-        @all_types.values
-      end
-
-      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|
-          if visibility_cache[defn]
-            if (dup_defn = non_dups.find { |d| d.graphql_name == defn.graphql_name })
-              raise_duplicate_definition(dup_defn, defn)
-            end
-            non_dups << defn
-          end
-        end
-        non_dups
-      end
-
-      def raise_duplicate_definition(first_defn, second_defn)
-        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
-        res = if @referenced_types[t].any? { |member| (member == true) || @cached_visible[member] }
-          if t.kind.abstract?
-            possible_types(t).any?
-          else
-            true
-          end
-        end
-        res
-      end
-
-      def load_all_types
-        return if @all_types_loaded
-        @all_types_loaded = true
-        schema_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] }
-            schema_types << orphan_type
-          end
-        end
-        schema_types.compact! # TODO why is this necessary?!
-        schema_types.flatten! # handle multiple defns
-        schema_types.each { |t| add_type(t, true) }
-
-        while t = @unvisited_types.pop
-          # These have already been checked for `.visible?`
-          visit_type(t)
-        end
-
-        @all_types.delete_if { |type_name, type_defn| !referenced?(type_defn) }
-        nil
-      end
-
-      def visit_type(type)
-        if type.kind.input_object?
-          # recurse into visible arguments
-          arguments(type).each do |argument|
-            add_type(argument.type.unwrap, argument)
-          end
-        elsif type.kind.union?
-          # recurse into visible possible types
-          type.type_memberships.each do |tm|
-            if @cached_visible[tm] && @cached_visible[tm.object_type]
-              add_type(tm.object_type, tm)
-            end
-          end
-        elsif type.kind.fields?
-          if type.kind.object?
-            # recurse into visible implemented interfaces
-            interfaces(type).each do |interface|
-              add_type(interface, type)
-            end
-          end
-
-          # recurse into visible fields
-          t_f = type.all_field_definitions
-          t_f.each do |field|
-            if @cached_visible[field]
-              field_type = field.type.unwrap
-              if field_type.kind.interface?
-                pt = @unfiltered_pt[field_type]
-                pt.each do |obj_type|
-                  if @cached_visible[obj_type] &&
-                      (tm = obj_type.interface_type_memberships.find { |tm| tm.abstract_type == field_type }) &&
-                      @cached_visible[tm]
-                    add_type(obj_type, tm)
-                  end
-                end
-              end
-              add_type(field_type, field)
-
-              # recurse into visible arguments
-              arguments(field).each do |argument|
-                add_type(argument.type.unwrap, argument)
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end