add tests for merging visibility.

Author: gmac

lib/graphql/stitching/composer.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require_relative "composer/base_validator"
-require_relative "composer/supergraph_directives"
 require_relative "composer/validate_interfaces"
 require_relative "composer/validate_type_resolvers"
 require_relative "composer/type_resolver_config"
@@ -55,6 +54,7 @@ def initialize(
         query_name: "Query",
         mutation_name: "Mutation",
         subscription_name: "Subscription",
+        visibility_profiles: [],
         description_merger: nil,
         deprecation_merger: nil,
         default_value_merger: nil,
@@ -74,6 +74,7 @@ def initialize(
         @resolver_map = {}
         @resolver_configs = {}
         @mapped_type_names = {}
+        @visibility_profiles = Set.new(visibility_profiles)
         @subgraph_directives_by_name_and_location = nil
         @subgraph_types_by_name_and_location = nil
         @schema_directives = nil
@@ -88,9 +89,9 @@ def perform(locations_input)
 
         directives_to_omit = [
           GraphQL::Stitching.stitch_directive,
-          KeyDirective.graphql_name,
-          ResolverDirective.graphql_name,
-          SourceDirective.graphql_name,
+          Directives::SupergraphKey.graphql_name,
+          Directives::SupergraphResolver.graphql_name,
+          Directives::SupergraphSource.graphql_name,
         ]
 
         # "directive_name" => "location" => subgraph_directive
@@ -184,6 +185,10 @@ def perform(locations_input)
         expand_abstract_resolvers(schema, schemas)
         apply_supergraph_directives(schema, @resolver_map, @field_map)
 
+        if (visibility_def = schema.directives[GraphQL::Stitching.visibility_directive])
+          visibility_def.get_argument("profiles").default_value(@visibility_profiles.to_a.sort)
+        end
+
         supergraph = Supergraph.from_definition(schema, executables: executables)
 
         COMPOSITION_VALIDATORS.each do |validator_class|
@@ -461,14 +466,6 @@ def build_merged_directives(type_name, members_by_location, owner, field_name: n
           # handled by deprecation_reason merger...
           next if directive_class.graphql_name == "deprecated"
 
-          if directive_class.graphql_name == GraphQL::Stitching.visibility_directive
-            unless GraphQL::Stitching.supports_visibility?
-              raise CompositionError, "Using `@#{GraphQL::Stitching.visibility_directive}` directive " \
-                "for schema visibility controls requires GraphQL Ruby v2.4.15 or later."
-            end
-            kwarg_merger = VISIBILITY_PROFILES_MERGER
-          end
-
           kwarg_values_by_name_location = directives_by_location.each_with_object({}) do |(location, directive), memo|
             directive.arguments.keyword_arguments.each do |key, value|
               key = key.to_s
@@ -479,6 +476,18 @@ def build_merged_directives(type_name, members_by_location, owner, field_name: n
             end
           end
 
+          if directive_class.graphql_name == GraphQL::Stitching.visibility_directive
+            unless GraphQL::Stitching.supports_visibility?
+              raise CompositionError, "Using `@#{GraphQL::Stitching.visibility_directive}` directive " \
+                "for schema visibility controls requires GraphQL Ruby v2.4.15 or later."
+            end
+
+            if (profiles = kwarg_values_by_name_location["profiles"])
+              @visibility_profiles.merge(profiles.each_value.reduce(&:|))
+              kwarg_merger = VISIBILITY_PROFILES_MERGER
+            end
+          end
+
           kwargs = kwarg_values_by_name_location.each_with_object({}) do |(kwarg_name, kwarg_values_by_location), memo|
             memo[kwarg_name.to_sym] = kwarg_merger.call(kwarg_values_by_location, {
               type_name: type_name,
@@ -705,8 +714,8 @@ def apply_supergraph_directives(schema, resolvers_by_type_name, locations_by_typ
 
             keys_for_type.each do |key, locations|
               locations.each do |location|
-                schema_directives[KeyDirective.graphql_name] ||= KeyDirective
-                type.directive(KeyDirective, key: key, location: location)
+                schema_directives[Directives::SupergraphKey.graphql_name] ||= Directives::SupergraphKey
+                type.directive(Directives::SupergraphKey, key: key, location: location)
               end
             end
 
@@ -722,8 +731,8 @@ def apply_supergraph_directives(schema, resolvers_by_type_name, locations_by_typ
                 type_name: (resolver.type_name if resolver.type_name != type_name),
               }
 
-              schema_directives[ResolverDirective.graphql_name] ||= ResolverDirective
-              type.directive(ResolverDirective, **params.tap(&:compact!))
+              schema_directives[Directives::SupergraphResolver.graphql_name] ||= Directives::SupergraphResolver
+              type.directive(Directives::SupergraphResolver, **params.tap(&:compact!))
             end
           end
 
@@ -749,8 +758,8 @@ def apply_supergraph_directives(schema, resolvers_by_type_name, locations_by_typ
 
             # Apply source directives to annotate the possible locations of each field
             locations_for_field.each do |location|
-              schema_directives[SourceDirective.graphql_name] ||= SourceDirective
-              field.directive(SourceDirective, location: location)
+              schema_directives[Directives::SupergraphSource.graphql_name] ||= Directives::SupergraphSource
+              field.directive(Directives::SupergraphSource, location: location)
             end
           end
         end

lib/graphql/stitching/composer/supergraph_directives.rb

@@ -10,5 +10,40 @@ class Stitch < GraphQL::Schema::Directive
       argument :type_name, String, required: false
       repeatable true
     end
+
+    class Visibility < GraphQL::Schema::Directive
+      graphql_name "visibility"
+      locations(OBJECT, INTERFACE, UNION, INPUT_OBJECT, ENUM, SCALAR, 
+        FIELD_DEFINITION, ARGUMENT_DEFINITION, INPUT_FIELD_DEFINITION, ENUM_VALUE)
+      argument :profiles, [String, null: false], required: true
+    end
+
+    class SupergraphKey < GraphQL::Schema::Directive
+      graphql_name "key"
+      locations OBJECT, INTERFACE, UNION
+      argument :key, String, required: true
+      argument :location, String, required: true
+      repeatable true
+    end
+
+    class SupergraphResolver < GraphQL::Schema::Directive
+      graphql_name "resolver"
+      locations OBJECT, INTERFACE, UNION
+      argument :location, String, required: true
+      argument :list, Boolean, required: false
+      argument :key, String, required: true
+      argument :field, String, required: true
+      argument :arguments, String, required: true
+      argument :argument_types, String, required: true
+      argument :type_name, String, required: false
+      repeatable true
+    end
+    
+    class SupergraphSource < GraphQL::Schema::Directive
+      graphql_name "source"
+      locations FIELD_DEFINITION
+      argument :location, String, required: true
+      repeatable true
+    end
   end
 end

lib/graphql/stitching/directives.rb

@@ -22,7 +22,7 @@ class Supergraph
       attr_reader :memoized_introspection_types
       attr_reader :locations_by_type_and_field
 
-      def initialize(schema:, fields: {}, resolvers: {}, executables: {})
+      def initialize(schema:, fields: {}, resolvers: {}, visibility_profiles: [], executables: {})
         @schema = schema
         @resolvers = resolvers
         @resolvers_by_version = nil
@@ -50,7 +50,12 @@ def initialize(schema:, fields: {}, resolvers: {}, executables: {})
           end
         end.freeze
 
-        @schema.use(GraphQL::Schema::AlwaysVisible)
+        if visibility_profiles.any?
+          profiles = visibility_profiles.each_with_object({ nil => {} }) { |p, m| m[p.to_s] = {} }
+          @schema.use(GraphQL::Schema::Visibility, profiles: profiles)
+        else
+          @schema.use(GraphQL::Schema::AlwaysVisible)
+        end
       end
 
       def to_definition

lib/graphql/stitching/supergraph.rb

@@ -4,13 +4,20 @@ module GraphQL::Stitching
   class Supergraph
     module Visibility
       def visible?(ctx)
+        # named_class = self.class
+        # named_class = self.superclass while named_class.name.nil?
+        # puts "#{named_class}, #{graphql_name}"
+
         profile = ctx[:visibility_profile]
         return true if profile.nil?
 
-        directive = directives.find { _1.graphql_name == Stitching.visibility_directive }
+        directive = directives.find { _1.graphql_name == GraphQL::Stitching.visibility_directive }
         return true if directive.nil?
 
-        directive.arguments.keyword_arguments[:profiles].include?(profile)
+        profiles = directive.arguments.keyword_arguments[:profiles]
+        return true if profiles.nil?
+
+        profiles.include?(profile)
       end
     end
 
@@ -24,18 +31,21 @@ class BaseField < GraphQL::Schema::Field
     end
 
     class BaseInputObject < GraphQL::Schema::InputObject
-      include Visibility
+      extend Visibility
       argument_class(BaseArgument)
     end
 
     module BaseInterface
       include GraphQL::Schema::Interface
-      include Visibility
       field_class(BaseField)
+
+      definition_methods do
+        include Visibility
+      end
     end
 
     class BaseObject < GraphQL::Schema::Object
-      include Visibility
+      extend Visibility
       field_class(BaseField)
     end
 
@@ -44,16 +54,16 @@ class BaseEnumValue < GraphQL::Schema::EnumValue
     end
 
     class BaseEnum < GraphQL::Schema::Enum
-      include Visibility
+      extend Visibility
       enum_value_class(BaseEnumValue)
     end
 
     class BaseScalar < GraphQL::Schema::Scalar
-      include Visibility
+      extend Visibility
     end
 
     class BaseUnion < GraphQL::Schema::Union
-      include Visibility
+      extend Visibility
     end
 
     BASE_TYPES = {

lib/graphql/stitching/supergraph/base_types.rb

@@ -17,17 +17,22 @@ def from_definition(schema, executables:)
             GraphQL::Schema.from_definition(schema)
           end
         end
-        
+
         field_map = {}
         resolver_map = {}
         possible_locations = {}
+        visibility_profiles = if (visibility_def = schema.directives[GraphQL::Stitching.visibility_directive])
+          visibility_def.get_argument("profiles").default_value
+        else
+          []
+        end
 
         schema.types.each do |type_name, type|
           next if type.introspection?
 
           # Collect/build key definitions for each type
           locations_by_key = type.directives.each_with_object({}) do |directive, memo|
-            next unless directive.graphql_name == Composer::KeyDirective.graphql_name
+            next unless directive.graphql_name == Directives::SupergraphKey.graphql_name
 
             kwargs = directive.arguments.keyword_arguments
             memo[kwargs[:key]] ||= []
@@ -40,45 +45,33 @@ def from_definition(schema, executables:)
 
           # Collect/build resolver definitions for each type
           type.directives.each do |d|
-            case d.graphql_name
-            when Composer::ResolverDirective.graphql_name
-              kwargs = d.arguments.keyword_arguments
-              resolver_map[type_name] ||= []
-              resolver_map[type_name] << TypeResolver.new(
-                location: kwargs[:location],
-                type_name: kwargs.fetch(:type_name, type_name),
-                field: kwargs[:field],
-                list: kwargs[:list] || false,
-                key: key_definitions[kwargs[:key]],
-                arguments: TypeResolver.parse_arguments_with_type_defs(kwargs[:arguments], kwargs[:argument_types]),
-              )
-            when Stitching.visibility_directive
-              # collect profiles...
-            end
+            next unless d.graphql_name == Directives::SupergraphResolver.graphql_name
+
+            kwargs = d.arguments.keyword_arguments
+            resolver_map[type_name] ||= []
+            resolver_map[type_name] << TypeResolver.new(
+              location: kwargs[:location],
+              type_name: kwargs.fetch(:type_name, type_name),
+              field: kwargs[:field],
+              list: kwargs[:list] || false,
+              key: key_definitions[kwargs[:key]],
+              arguments: TypeResolver.parse_arguments_with_type_defs(kwargs[:arguments], kwargs[:argument_types]),
+            )
           end
 
-          if type.kind.fields?
-            type.fields.each do |field_name, field|
-              # Collection locations for each field definition
-              field.directives.each do |d|
-                case d.graphql_name
-                when Composer::SourceDirective.graphql_name
-                  location = d.arguments.keyword_arguments[:location]
-                  field_map[type_name] ||= {}
-                  field_map[type_name][field_name] ||= []
-                  field_map[type_name][field_name] << location
-                  possible_locations[location] = true
-                when Stitching.visibility_directive
-                  # collect profiles...
-                end
-              end
+          next unless type.kind.fields?
 
-              collect_visibility_profiles(field.arguments)
+          type.fields.each do |field_name, field|
+            # Collection locations for each field definition
+            field.directives.each do |d|
+              next unless d.graphql_name == Directives::SupergraphSource.graphql_name
+              
+              location = d.arguments.keyword_arguments[:location]
+              field_map[type_name] ||= {}
+              field_map[type_name][field_name] ||= []
+              field_map[type_name][field_name] << location
+              possible_locations[location] = true
             end
-          elsif type.kind.input_object?
-            collect_visibility_profiles(type.arguments)
-          elsif type.kind.enum?
-            collect_visibility_profiles(type.values)
           end
         end
 
@@ -93,18 +86,10 @@ def from_definition(schema, executables:)
           schema: schema,
           fields: field_map,
           resolvers: resolver_map,
+          visibility_profiles: visibility_profiles,
           executables: executables,
         )
       end
-
-      def collect_visibility_profiles(elements)
-        elements.each do |element_name, element|
-          element.directives.each do |d|
-            next unless d.graphql_name == Stitching.visibility_directive
-            # collect profiles...
-          end
-        end
-      end
     end
   end
 end