supergraph visibility controls.

Author: gmac

lib/graphql/stitching.rb

@@ -32,8 +32,6 @@ def initialize(element)
     end
 
     class << self
-      attr_writer :stitch_directive
-
       # Proc used to compute digests; uses SHA2 by default.
       # @returns [Proc] proc used to compute digests.
       def digest(&block)
@@ -49,6 +47,25 @@ def digest(&block)
       def stitch_directive
         @stitch_directive ||= "stitch"
       end
+
+      attr_writer :stitch_directive
+
+      # Name of the directive used to denote member visibilities.
+      # @returns [String] name of the visibility directive.
+      def visibility_directive
+        @visibility_directive ||= "visibility"
+      end
+
+      attr_writer :visibility_directive
+
+      # @returns Boolean true if GraphQL::Schema::Visibility is fully supported
+      def supports_visibility?
+        return @supports_visibility if defined?(@supports_visibility)
+
+        # Requires `Visibility` (v2.4) and `Schema.from_definition(base_types:)` (v2.4.15)
+        @supports_visibility = Object.const_defined?("GraphQL::Schema::Visibility") && 
+          GraphQL::Schema.method(:from_definition).parameters.any? { _1.last == :base_types }
+      end
     end
   end
 end

lib/graphql/stitching/client.rb

@@ -13,16 +13,18 @@ class Client
       # Builds a new client instance. Either `supergraph` or `locations` configuration is required.
       # @param supergraph [Supergraph] optional, a pre-composed supergraph that bypasses composer setup.
       # @param locations [Hash<Symbol, Hash<Symbol, untyped>>] optional, composer configurations for each graph location.
-      # @param composer [Composer] optional, a pre-configured composer instance for use with `locations` configuration.
-      def initialize(locations: nil, supergraph: nil, composer: nil)
+      # @param composer_options [Hash] optional, composer options for configuring composition.
+      def initialize(locations: nil, supergraph: nil, composer_options: {})
         @supergraph = if locations && supergraph
           raise ArgumentError, "Cannot provide both locations and a supergraph."
         elsif supergraph && !supergraph.is_a?(Supergraph)
           raise ArgumentError, "Provided supergraph must be a GraphQL::Stitching::Supergraph instance."
+        elsif supergraph && composer_options.any?
+          raise ArgumentError, "Cannot provide composer options with a pre-built supergraph."
         elsif supergraph
           supergraph
         else
-          composer ||= Composer.new
+          composer = Composer.new(**composer_options)
           composer.perform(locations)
         end
 

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"
@@ -23,6 +22,9 @@ class Composer
 
       # @api private
       BASIC_VALUE_MERGER = ->(values_by_location, _info) { values_by_location.values.find { !_1.nil? } }
+      
+      # @api private
+      VISIBILITY_PROFILES_MERGER = ->(values_by_location, _info) { values_by_location.values.reduce(:&) }
 
       # @api private
       BASIC_ROOT_FIELD_LOCATION_SELECTOR = ->(locations, _info) { locations.last }
@@ -52,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,
@@ -71,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
@@ -85,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
@@ -181,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|
@@ -237,7 +245,7 @@ def build_scalar_type(type_name, types_by_location)
 
         builder = self
 
-        Class.new(GraphQL::Schema::Scalar) do
+        Class.new(GraphQL::Stitching::Supergraph::BaseScalar) do
           graphql_name(type_name)
           description(builder.merge_descriptions(type_name, types_by_location))
           builder.build_merged_directives(type_name, types_by_location, self)
@@ -264,7 +272,7 @@ def build_enum_type(type_name, types_by_location, enum_usage)
           end
         end
 
-        Class.new(GraphQL::Schema::Enum) do
+        Class.new(GraphQL::Stitching::Supergraph::BaseEnum) do
           graphql_name(type_name)
           description(builder.merge_descriptions(type_name, types_by_location))
           builder.build_merged_directives(type_name, types_by_location, self)
@@ -286,7 +294,7 @@ def build_enum_type(type_name, types_by_location, enum_usage)
       def build_object_type(type_name, types_by_location)
         builder = self
 
-        Class.new(GraphQL::Schema::Object) do
+        Class.new(GraphQL::Stitching::Supergraph::BaseObject) do
           graphql_name(type_name)
           description(builder.merge_descriptions(type_name, types_by_location))
 
@@ -306,7 +314,7 @@ def build_interface_type(type_name, types_by_location)
         builder = self
 
         Module.new do
-          include GraphQL::Schema::Interface
+          include GraphQL::Stitching::Supergraph::BaseInterface
           graphql_name(type_name)
           description(builder.merge_descriptions(type_name, types_by_location))
 
@@ -325,7 +333,7 @@ def build_interface_type(type_name, types_by_location)
       def build_union_type(type_name, types_by_location)
         builder = self
 
-        Class.new(GraphQL::Schema::Union) do
+        Class.new(GraphQL::Stitching::Supergraph::BaseUnion) do
           graphql_name(type_name)
           description(builder.merge_descriptions(type_name, types_by_location))
 
@@ -340,7 +348,7 @@ def build_union_type(type_name, types_by_location)
       def build_input_object_type(type_name, types_by_location)
         builder = self
 
-        Class.new(GraphQL::Schema::InputObject) do
+        Class.new(GraphQL::Stitching::Supergraph::BaseInputObject) do
           graphql_name(type_name)
           description(builder.merge_descriptions(type_name, types_by_location))
           builder.build_merged_arguments(type_name, types_by_location, self)
@@ -451,6 +459,7 @@ def build_merged_directives(type_name, members_by_location, owner, field_name: n
         end
 
         directives_by_name_location.each do |directive_name, directives_by_location|
+          kwarg_merger = @directive_kwarg_merger
           directive_class = @schema_directives[directive_name]
           next unless directive_class
 
@@ -467,8 +476,20 @@ 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] = @directive_kwarg_merger.call(kwarg_values_by_location, {
+            memo[kwarg_name.to_sym] = kwarg_merger.call(kwarg_values_by_location, {
               type_name: type_name,
               field_name: field_name,
               argument_name: argument_name,
@@ -693,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
 
@@ -710,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
 
@@ -737,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,42 @@ 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

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require_relative "supergraph/base_types"
 require_relative "supergraph/from_definition"
 
 module GraphQL
@@ -21,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
@@ -49,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