graphql 1.12.12 → 2.4.8

data/lib/graphql/schema/addition.rb

@@ -12,7 +12,7 @@ module GraphQL
         @possible_types = {}
         @types = {}
         @union_memberships = {}
-        @references = Hash.new { |h, k| h[k] = [] }
+        @references = Hash.new { |h, k| h[k] = Set.new }
         @arguments_with_default_values = []
         add_type_and_traverse(new_types)
       end
@@ -20,11 +20,17 @@ module GraphQL
       private
 
       def references_to(thing, from:)
-        @references[thing] << from
+        @references[thing].add(from)
       end
 
       def get_type(name)
-        @types[name] || @schema.get_type(name)
+        local_type = @types[name]
+        # This isn't really sophisticated, but
+        # I think it's good enough to support the current usage of LateBoundTypes
+        if local_type.is_a?(Array)
+          local_type = local_type.first
+        end
+        local_type || @schema.get_type(name)
       end
 
       # Lookup using `own_types` here because it's ok to override
@@ -34,14 +40,21 @@ module GraphQL
       end
 
       def add_directives_from(owner)
-        dirs = owner.directives.map(&:class)
-        @directives.merge(dirs)
-        add_type_and_traverse(dirs)
+        if !(dir_instances = owner.directives).empty?
+          dirs = dir_instances.map(&:class)
+          @directives.merge(dirs)
+          add_type_and_traverse(dirs)
+        end
       end
 
       def add_type_and_traverse(new_types)
         late_types = []
-        new_types.each { |t| add_type(t, owner: nil, late_types: late_types, path: [t.graphql_name]) }
+        path = []
+        new_types.each do |t|
+          path.push(t.graphql_name)
+          add_type(t, owner: nil, late_types: late_types, path: path)
+          path.pop
+        end
         missed_late_types = 0
         while (late_type_vals = late_types.shift)
           type_owner, lt = late_type_vals
@@ -77,13 +90,13 @@ module GraphQL
 
       def update_type_owner(owner, type)
         case owner
-        when Class
+        when Module
           if owner.kind.union?
             # It's a union with possible_types
             # Replace the item by class name
             owner.assign_type_membership_object_type(type)
-            @possible_types[owner.graphql_name] = owner.possible_types
-          elsif type.kind.interface? && owner.kind.object?
+            @possible_types[owner] = owner.possible_types
+          elsif type.kind.interface? && (owner.kind.object? || owner.kind.interface?)
             new_interfaces = []
             owner.interfaces.each do |int_t|
               if int_t.is_a?(String) && int_t == type.graphql_name
@@ -97,18 +110,23 @@ module GraphQL
             end
             owner.implements(*new_interfaces)
             new_interfaces.each do |int|
-              pt = @possible_types[int.graphql_name] ||= []
-              if !pt.include?(owner)
+              pt = @possible_types[int] ||= []
+              if !pt.include?(owner) && owner.is_a?(Class)
                 pt << owner
               end
+              int.interfaces.each do |indirect_int|
+                if indirect_int.is_a?(LateBoundType) && (indirect_int_type = get_type(indirect_int.graphql_name))
+                  update_type_owner(owner, indirect_int_type)
+                end
+              end
             end
           end
-
         when nil
           # It's a root type
           @types[type.graphql_name] = type
         when GraphQL::Schema::Field, GraphQL::Schema::Argument
           orig_type = owner.type
+          unwrapped_t = type
           # Apply list/non-null wrapper as needed
           if orig_type.respond_to?(:of_type)
             transforms = []
@@ -125,20 +143,14 @@ module GraphQL
             transforms.reverse_each { |t| type = type.public_send(t) }
           end
           owner.type = type
+          references_to(unwrapped_t, from: owner)
         else
           raise "Unexpected update: #{owner.inspect} #{type.inspect}"
         end
       end
 
       def add_type(type, owner:, late_types:, path:)
-        if type.respond_to?(:metadata) && type.metadata.is_a?(Hash)
-          type_class = type.metadata[:type_class]
-          if type_class.nil?
-            raise ArgumentError, "Can't add legacy type: #{type} (#{type.class})"
-          else
-            type = type_class
-          end
-        elsif type.is_a?(String) || type.is_a?(GraphQL::Schema::LateBoundType)
+        if type.is_a?(String) || type.is_a?(GraphQL::Schema::LateBoundType)
           late_types << [owner, type]
           return
         end
@@ -148,79 +160,104 @@ module GraphQL
           um << owner
         end
 
-        if (prev_type = get_local_type(type.graphql_name))
-          if prev_type != type
-            raise DuplicateTypeNamesError.new(
-              type_name: type.graphql_name,
-              first_definition: prev_type,
-              second_definition: type,
-              path: path,
-            )
-          else
-            # This type was already added
-          end
+        if (prev_type = get_local_type(type.graphql_name)) && (prev_type == type || (prev_type.is_a?(Array) && prev_type.include?(type)))
+          # No need to re-visit
         elsif type.is_a?(Class) && type < GraphQL::Schema::Directive
           @directives << type
-          type.arguments.each do |name, arg|
+          type.all_argument_definitions.each do |arg|
             arg_type = arg.type.unwrap
-            references_to(arg_type, from: arg)
-            add_type(arg_type, owner: arg, late_types: late_types, path: path + [name])
+            if !arg_type.is_a?(GraphQL::Schema::LateBoundType)
+              references_to(arg_type, from: arg)
+            end
+            path.push(arg.graphql_name)
+            add_type(arg_type, owner: arg, late_types: late_types, path: path)
+            path.pop
             if arg.default_value?
               @arguments_with_default_values << arg
             end
           end
         else
-          @types[type.graphql_name] = type
+          prev_type = @types[type.graphql_name]
+          if prev_type.nil?
+            @types[type.graphql_name] = type
+          elsif prev_type.is_a?(Array)
+            prev_type << type
+          else
+            @types[type.graphql_name] = [prev_type, type]
+          end
+
           add_directives_from(type)
           if type.kind.fields?
-            type.fields.each do |name, field|
+            type.all_field_definitions.each do |field|
+              field.ensure_loaded
+              name = field.graphql_name
               field_type = field.type.unwrap
-              references_to(field_type, from: field)
-              field_path = path + [name]
-              add_type(field_type, owner: field, late_types: late_types, path: field_path)
+              if !field_type.is_a?(GraphQL::Schema::LateBoundType)
+                references_to(field_type, from: field)
+              end
+              path.push(name)
+              add_type(field_type, owner: field, late_types: late_types, path: path)
               add_directives_from(field)
-              field.arguments.each do |arg_name, arg|
+              field.all_argument_definitions.each do |arg|
                 add_directives_from(arg)
                 arg_type = arg.type.unwrap
-                references_to(arg_type, from: arg)
-                add_type(arg_type, owner: arg, late_types: late_types, path: field_path + [arg_name])
+                if !arg_type.is_a?(GraphQL::Schema::LateBoundType)
+                  references_to(arg_type, from: arg)
+                end
+                path.push(arg.graphql_name)
+                add_type(arg_type, owner: arg, late_types: late_types, path: path)
+                path.pop
                 if arg.default_value?
                   @arguments_with_default_values << arg
                 end
               end
+              path.pop
             end
           end
           if type.kind.input_object?
-            type.arguments.each do |arg_name, arg|
+            type.all_argument_definitions.each do |arg|
               add_directives_from(arg)
               arg_type = arg.type.unwrap
-              references_to(arg_type, from: arg)
-              add_type(arg_type, owner: arg, late_types: late_types, path: path + [arg_name])
+              if !arg_type.is_a?(GraphQL::Schema::LateBoundType)
+                references_to(arg_type, from: arg)
+              end
+              path.push(arg.graphql_name)
+              add_type(arg_type, owner: arg, late_types: late_types, path: path)
+              path.pop
               if arg.default_value?
                 @arguments_with_default_values << arg
               end
             end
           end
           if type.kind.union?
-            @possible_types[type.graphql_name] = type.possible_types
-            type.possible_types.each do |t|
-              add_type(t, owner: type, late_types: late_types, path: path + ["possible_types"])
+            @possible_types[type] = type.all_possible_types
+            path.push("possible_types")
+            type.all_possible_types.each do |t|
+              add_type(t, owner: type, late_types: late_types, path: path)
             end
+            path.pop
           end
           if type.kind.interface?
+            path.push("orphan_types")
             type.orphan_types.each do |t|
-              add_type(t, owner: type, late_types: late_types, path: path + ["orphan_types"])
+              add_type(t, owner: type, late_types: late_types, path: path)
             end
+            path.pop
           end
           if type.kind.object?
-            @possible_types[type.graphql_name] = [type]
+            possible_types_for_this_name = @possible_types[type] ||= []
+            possible_types_for_this_name << type
+          end
+
+          if type.kind.object? || type.kind.interface?
+            path.push("implements")
             type.interface_type_memberships.each do |interface_type_membership|
               case interface_type_membership
               when Schema::TypeMembership
                 interface_type = interface_type_membership.abstract_type
                 # We can get these now; we'll have to get late-bound types later
-                if interface_type.is_a?(Module)
-                  implementers = @possible_types[interface_type.graphql_name] ||= []
+                if interface_type.is_a?(Module) && type.is_a?(Class)
+                  implementers = @possible_types[interface_type] ||= []
                   implementers << type
                 end
               when String, Schema::LateBoundType
@@ -228,7 +265,14 @@ module GraphQL
               else
                 raise ArgumentError, "Invariant: unexpected type membership for #{type.graphql_name}: #{interface_type_membership.class} (#{interface_type_membership.inspect})"
               end
-              add_type(interface_type, owner: type, late_types: late_types, path: path + ["implements"])
+              add_type(interface_type, owner: type, late_types: late_types, path: path)
+            end
+            path.pop
+          end
+
+          if type.kind.enum?
+            type.all_enum_value_definitions.each do |value_definition|
+              add_directives_from(value_definition)
             end
           end
         end

data/lib/graphql/schema/always_visible.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+module GraphQL
+  class Schema
+    module AlwaysVisible
+      def self.use(schema, **opts)
+        schema.extend(self)
+      end
+
+      def visible?(_member, _context)
+        true
+      end
+    end
+  end
+end