graphql-stitching 1.6.2 → 1.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b6b2cc734796d7455701bcc5b376a8efb49534c43b7a75de53bc1f2e686bf54c
-  data.tar.gz: 449c09b94257de6ae720b4b7938c13b8881da9f1f8dc7684aabdc4c493b2c6d2
+  metadata.gz: 63b137317e57972e09c9926447c53ab26ac99a146557258e94b62abff305d096
+  data.tar.gz: e3a2217f5c04cc1a8a8412f15bb0ee5e6c4340869f945758735468c0903840f6
 SHA512:
-  metadata.gz: 94345a14cc9bcee462854188b543a170b3dbd65cc948e55773e1a07357f47026f41018ea35eedbacc8647d8a92634be1f143d86543f0ea092f48ddb1281a86f5
-  data.tar.gz: ae7cb67b6f36ca209f327d43bd293fa6afc4e6a93e8e91e83f4acf2893b744831836959402cd236e789ade5602857bb39d484025ea58c7e16d19b9ec5eb69d67
+  metadata.gz: 63ccfdcf28c02490946d2b7b9fef5dbe726cc47a214887010dc7dfa7f066d266bb7b2e5d899b13ad705060b8f7981904f47029a119c73c1aa582181d97ec6bec
+  data.tar.gz: d72baafd4419199658afbdba8a70a109a84da1e48e712344f568a5d4f75f5d0b2da3f3549a50370e528357fd003d9f8cbae825a490b2b0eed86c84528471855f

data/README.md

@@ -9,6 +9,7 @@ GraphQL stitching composes a single schema from multiple underlying GraphQL reso
 - Merged object and abstract types joining though multiple keys.
 - Shared objects, fields, enums, and inputs across locations.
 - Combining local and remote schemas.
+- [Visibility controls](./docs/visibility.md) for hiding schema elements.
 - [File uploads](./docs/http_executable.md) via multipart forms.
 - Tested with all minor versions of `graphql-ruby`.
 
@@ -171,11 +172,11 @@ GRAPHQL
 client = GraphQL::Stitching::Client.new(locations: {
   products: {
     schema: GraphQL::Schema.from_definition(products_schema),
-    executable:  GraphQL::Stitching::HttpExecutable.new(url: "http://localhost:3001"),
+    executable: GraphQL::Stitching::HttpExecutable.new(url: "http://localhost:3001"),
   },
   catalog: {
     schema: GraphQL::Schema.from_definition(catalog_schema),
-    executable:  GraphQL::Stitching::HttpExecutable.new(url: "http://localhost:3002"),
+    executable: GraphQL::Stitching::HttpExecutable.new(url: "http://localhost:3002"),
   },
 })
 ```
@@ -358,20 +359,12 @@ type Query {
 
 #### Class-based schemas
 
-The `@stitch` directive can be added to class-based schemas with a directive class:
+The `@stitch` directive can be added to class-based schemas with a directive definition provided by the library:
 
 ```ruby
-class StitchingResolver < GraphQL::Schema::Directive
-  graphql_name "stitch"
-  locations FIELD_DEFINITION
-  repeatable true
-  argument :key, String, required: true
-  argument :arguments, String, required: false
-end
-
 class Query < GraphQL::Schema::Object
   field :product, Product, null: false do
-    directive StitchingResolver, key: "id"
+    directive GraphQL::Stitching::Directives::Stitch, key: "id"
     argument :id, ID, required: true
   end
 end
@@ -485,6 +478,7 @@ The [Executor](./docs/executor.md) component builds atop the Ruby fiber-based im
 
 - [Deploying a stitched schema](./docs/mechanics.md#deploying-a-stitched-schema)
 - [Schema composition merge patterns](./docs/composer.md#merge-patterns)
+- [Visibility controls](./docs/visibility.md)
 - [Subscriptions tutorial](./docs/subscriptions.md)
 - [Field selection routing](./docs/mechanics.md#field-selection-routing)
 - [Root selection routing](./docs/mechanics.md#root-selection-routing)

data/docs/visibility.md

@@ -0,0 +1,168 @@
+# Visibility
+
+Visibility controls can hide parts of a supergraph from select audiences without compromising stitching operations. Restricted schema elements are hidden from introspection and validate as though they do not exist (which is different from traditional authorization where an element is acknowledged as restricted). Visibility is useful for managing multiple distributions of a schema for different audiences.
+
+Under the hood, this system wraps `GraphQL::Schema::Visibility` (with nil profile support) and requires at least GraphQL Ruby v2.5.3.
+
+## Example
+
+Schemas may include a `@visibility` directive that defines element _profiles_. A profile is just a label describing an API distribution (public, private, etc). When a request is assigned a visibility profile, it can only access elements belonging to that profile. Elements without an explicit `@visibility` constraint belong to all profiles. For example:
+
+_schemas/product_info.graphql_
+```graphql
+directive @stitch(key: String!) on FIELD_DEFINITION
+directive @visibility(profiles: [String!]!) on OBJECT | INTERFACE | UNION | INPUT_OBJECT | ENUM | SCALAR | FIELD_DEFINITION | ARGUMENT_DEFINITION | INPUT_FIELD_DEFINITION | ENUM_VALUE
+
+type Product {
+  id: ID!
+  title: String!
+  description: String!
+}
+
+type Query {
+  featuredProduct: Product
+  product(id: ID!): Product @stitch(key: "id") @visibility(profiles: ["private"])
+}
+```
+
+_schemas/product_prices.graphql_
+```graphql
+directive @stitch(key: String!) on FIELD_DEFINITION
+directive @visibility(profiles: [String!]!) on OBJECT | INTERFACE | UNION | INPUT_OBJECT | ENUM | SCALAR | FIELD_DEFINITION | ARGUMENT_DEFINITION | INPUT_FIELD_DEFINITION | ENUM_VALUE
+
+type Product {
+  id: ID! @visibility(profiles: [])
+  msrp: Float! @visibility(profiles: ["private"])
+  price: Float!
+}
+
+type Query {
+  products(ids: [ID!]!): [Product]! @stitch(key: "id") @visibility(profiles: ["private"])
+}
+```
+
+When composing a stitching client, the names of all possible visibility profiles that the supergraph responds to should be specified in composer options:
+
+```ruby
+client = GraphQL::Stitching::Client.new(
+  composer_options: {
+    visibility_profiles: ["public", "private"],
+  },
+  locations: {
+    info: {
+      schema: GraphQL::Schema.from_definition(File.read("schemas/product_info.graphql")),
+      executable: GraphQL::Stitching::HttpExecutable.new(url: "http://localhost:3001"),
+    },
+    prices: {
+      schema: GraphQL::Schema.from_definition(File.read("schemas/product_prices.graphql")),
+      executable: GraphQL::Stitching::HttpExecutable.new(url: "http://localhost:3002"),
+    },
+  }
+)
+```
+
+The client can then execute requests with a `visibility_profile` parameter in context that specifies the name of any profile the supergraph was composed with, or nil:
+
+```ruby
+query = %|{
+  featuredProduct {
+    title  # always visible
+    price  # always visible
+    msrp   # only visible to internal and nil profiles
+    id     # only visible to nil profile
+  }
+}|
+
+result = client.execute(query, context: { 
+  visibility_profile: "public", # << or private, or nil
+})
+```
+
+The `visibility_profile` parameter will select which visibility distribution to use while introspecting and validating the request. For example:
+
+- Using `visibility_profile: "public"` will say the `msrp` field does not exist (because it is restricted to "private").
+- Using `visibility_profile: "private"` will accesses the `msrp` field as usual. 
+- Using `visibility_profile: nil` will access the entire graph without any visibility constraints.
+
+The full potential of visibility comes when hiding stitching implementation details, such as the `id` field (which is the stitching key for the Product type). While the `id` field is hidden from all named profiles, it remains operational for the stitching implementation.
+
+## Adding visibility directives
+
+Add the `@visibility` directive into schemas using the library definition:
+
+```ruby
+class QueryType < GraphQL::Schema::Object
+  field :my_field, String, null: true do |f|
+    f.directive(GraphQL::Stitching::Directives::Visibility, profiles: ["private"])
+  end
+end
+
+class MySchema < GraphQL::Schema
+  directive(GraphQL::Stitching::Directives::Visibility)
+  query(QueryType)
+end
+```
+
+## Merging visibilities
+
+Visibility directives merge across schemas into the narrowest constraint possible. Profile sets for an element will intersect into its supergraph constraint:
+
+```graphql
+# location 1
+myField: String @visibility(profiles: ["a", "c"])
+
+# location 2
+myField: String @visibility(profiles: ["b", "c"])
+
+# merged supergraph
+myField: String @visibility(profiles: ["c"])
+```
+
+This may cause an element's profiles to intersect into an empty set, which means the element belongs to no profiles and will be hidden from all named distributions:
+
+```graphql
+# location 1
+myField: String @visibility(profiles: ["a"])
+
+# location 2
+myField: String @visibility(profiles: ["b"])
+
+# merged supergraph
+myField: String @visibility(profiles: [])
+```
+
+Locations may omit visibility information to give other locations full control. Remember that elements without a `@visibility` constraint belong to all profiles, which also applies while merging:
+
+```graphql
+# location 1
+myField: String
+
+# location 2
+myField: String @visibility(profiles: ["b"])
+
+# merged supergraph
+myField: String @visibility(profiles: ["b"])
+```
+
+## Type controls
+
+Visibility controls can be applied to almost all GraphQL schema elements, including:
+
+- Types (Object, Interface, Union, Enum, Scalar, InputObject)
+- Fields (of Object and Interface)
+- Arguments (of Field and InputObject)
+- Enum values
+
+While the visibility of type members (fields, arguments, and enum values) are pretty intuitive, the visibility of parent types is far more nuanced as constraints start to cascade:
+
+```graphql
+type Widget @visibility(profiles: ["private"]) {
+  title: String
+}
+
+type Query {
+  widget: Widget # << GETS HIDDEN
+}
+```
+
+In this example, hiding the `Widget` type will also hide the `Query.widget` field that returns it.

data/lib/graphql/stitching/client.rb

@@ -13,16 +13,18 @@ module GraphQL
       # 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
 

data/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 @@ module GraphQL
 
       # @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 @@ module GraphQL
         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 @@ module GraphQL
         @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 @@ module GraphQL
 
         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 @@ module GraphQL
         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 @@ module GraphQL
 
         builder = self
 
-        Class.new(GraphQL::Schema::Scalar) do
+        Class.new(GraphQL::Stitching::Supergraph::ScalarType) 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 @@ module GraphQL
           end
         end
 
-        Class.new(GraphQL::Schema::Enum) do
+        Class.new(GraphQL::Stitching::Supergraph::EnumType) 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 @@ module GraphQL
       def build_object_type(type_name, types_by_location)
         builder = self
 
-        Class.new(GraphQL::Schema::Object) do
+        Class.new(GraphQL::Stitching::Supergraph::ObjectType) do
           graphql_name(type_name)
           description(builder.merge_descriptions(type_name, types_by_location))
 
@@ -306,7 +314,7 @@ module GraphQL
         builder = self
 
         Module.new do
-          include GraphQL::Schema::Interface
+          include GraphQL::Stitching::Supergraph::InterfaceType
           graphql_name(type_name)
           description(builder.merge_descriptions(type_name, types_by_location))
 
@@ -325,7 +333,7 @@ module GraphQL
       def build_union_type(type_name, types_by_location)
         builder = self
 
-        Class.new(GraphQL::Schema::Union) do
+        Class.new(GraphQL::Stitching::Supergraph::UnionType) do
           graphql_name(type_name)
           description(builder.merge_descriptions(type_name, types_by_location))
 
@@ -340,7 +348,7 @@ module GraphQL
       def build_input_object_type(type_name, types_by_location)
         builder = self
 
-        Class.new(GraphQL::Schema::InputObject) do
+        Class.new(GraphQL::Stitching::Supergraph::InputObjectType) 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 @@ module GraphQL
         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 @@ module GraphQL
             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 v#{GraphQL::Stitching::MIN_VISIBILITY_VERSION} 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 @@ module GraphQL
   
             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 @@ module GraphQL
                 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 @@ module GraphQL
   
             # 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

data/lib/graphql/stitching/{composer/supergraph_directives.rb → directives.rb}

@@ -1,8 +1,26 @@
 # frozen_string_literal: true
 
 module GraphQL::Stitching
-  class Composer
-    class KeyDirective < GraphQL::Schema::Directive
+  module Directives
+    class Stitch < GraphQL::Schema::Directive
+      graphql_name "stitch"
+      locations FIELD_DEFINITION
+      argument :key, String, required: true
+      argument :arguments, String, required: false
+      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
@@ -10,7 +28,7 @@ module GraphQL::Stitching
       repeatable true
     end
 
-    class ResolverDirective < GraphQL::Schema::Directive
+    class SupergraphResolver < GraphQL::Schema::Directive
       graphql_name "resolver"
       locations OBJECT, INTERFACE, UNION
       argument :location, String, required: true
@@ -23,7 +41,7 @@ module GraphQL::Stitching
       repeatable true
     end
     
-    class SourceDirective < GraphQL::Schema::Directive
+    class SupergraphSource < GraphQL::Schema::Directive
       graphql_name "source"
       locations FIELD_DEFINITION
       argument :location, String, required: true

data/lib/graphql/stitching/supergraph/from_definition.rb

@@ -10,17 +10,29 @@ module GraphQL::Stitching
       end
 
       def from_definition(schema, executables:)
-        schema = GraphQL::Schema.from_definition(schema) if schema.is_a?(String)
+        if schema.is_a?(String)
+          schema = if GraphQL::Stitching.supports_visibility?
+            GraphQL::Schema.from_definition(schema, base_types: BASE_TYPES)
+          else
+            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]] ||= []
@@ -32,10 +44,10 @@ module GraphQL::Stitching
           end
 
           # Collect/build resolver definitions for each type
-          type.directives.each do |directive|
-            next unless directive.graphql_name == Composer::ResolverDirective.graphql_name
+          type.directives.each do |d|
+            next unless d.graphql_name == Directives::SupergraphResolver.graphql_name
 
-            kwargs = directive.arguments.keyword_arguments
+            kwargs = d.arguments.keyword_arguments
             resolver_map[type_name] ||= []
             resolver_map[type_name] << TypeResolver.new(
               location: kwargs[:location],
@@ -52,8 +64,8 @@ module GraphQL::Stitching
           type.fields.each do |field_name, field|
             # Collection locations for each field definition
             field.directives.each do |d|
-              next unless d.graphql_name == Composer::SourceDirective.graphql_name
-
+              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] ||= []
@@ -74,6 +86,7 @@ module GraphQL::Stitching
           schema: schema,
           fields: field_map,
           resolvers: resolver_map,
+          visibility_profiles: visibility_profiles,
           executables: executables,
         )
       end

data/lib/graphql/stitching/supergraph/types.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module GraphQL::Stitching
+  class Supergraph
+    module Visibility
+      def visible?(ctx)
+        profile = ctx[:visibility_profile]
+        return true if profile.nil?
+
+        directive = directives.find { _1.graphql_name == GraphQL::Stitching.visibility_directive }
+        return true if directive.nil?
+
+        profiles = directive.arguments.keyword_arguments[:profiles]
+        return true if profiles.nil?
+
+        profiles.include?(profile)
+      end
+    end
+    
+    class ArgumentType < GraphQL::Schema::Argument
+      include Visibility
+    end
+
+    class FieldType < GraphQL::Schema::Field
+      include Visibility
+      argument_class(ArgumentType)
+    end
+
+    class InputObjectType < GraphQL::Schema::InputObject
+      extend Visibility
+      argument_class(ArgumentType)
+    end
+
+    module InterfaceType
+      include GraphQL::Schema::Interface
+      field_class(FieldType)
+
+      definition_methods do
+        include Visibility
+      end
+    end
+
+    class ObjectType < GraphQL::Schema::Object
+      extend Visibility
+      field_class(FieldType)
+    end
+
+    class EnumValueType < GraphQL::Schema::EnumValue
+      include Visibility
+    end
+
+    class EnumType < GraphQL::Schema::Enum
+      extend Visibility
+      enum_value_class(EnumValueType)
+    end
+    
+    class ScalarType < GraphQL::Schema::Scalar
+      extend Visibility
+    end
+
+    class UnionType < GraphQL::Schema::Union
+      extend Visibility
+    end
+
+    BASE_TYPES = {
+      enum: EnumType,
+      input_object: InputObjectType,
+      interface: InterfaceType,
+      object: ObjectType,
+      scalar: ScalarType,
+      union: UnionType,
+    }.freeze
+  end
+end

data/lib/graphql/stitching/supergraph.rb

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

data/lib/graphql/stitching/version.rb

@@ -2,6 +2,6 @@
 
 module GraphQL
   module Stitching
-    VERSION = "1.6.2"
+    VERSION = "1.7.0"
   end
 end

data/lib/graphql/stitching.rb

@@ -32,8 +32,6 @@ module GraphQL
     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,10 +47,31 @@ module GraphQL
       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
+
+      MIN_VISIBILITY_VERSION = "2.5.3"
+
+      # @returns Boolean true if GraphQL::Schema::Visibility is fully supported
+      def supports_visibility?
+        return @supports_visibility if defined?(@supports_visibility)
+
+        # Requires `Visibility` (v2.4) with nil profile support (v2.5.3)
+        @supports_visibility = Gem::Version.new(GraphQL::VERSION) >= Gem::Version.new(MIN_VISIBILITY_VERSION)
+      end
     end
   end
 end
 
+require_relative "stitching/directives"
 require_relative "stitching/supergraph"
 require_relative "stitching/client"
 require_relative "stitching/composer"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql-stitching
 version: !ruby/object:Gem::Version
-  version: 1.6.2
+  version: 1.7.0
 platform: ruby
 authors:
 - Greg MacWilliam
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-04-26 00:00:00.000000000 Z
+date: 2025-05-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: graphql
@@ -92,6 +92,7 @@ files:
 - docs/subscriptions.md
 - docs/supergraph.md
 - docs/type_resolver.md
+- docs/visibility.md
 - examples/file_uploads/Gemfile
 - examples/file_uploads/Procfile
 - examples/file_uploads/README.md
@@ -161,10 +162,10 @@ files:
 - lib/graphql/stitching/client.rb
 - lib/graphql/stitching/composer.rb
 - lib/graphql/stitching/composer/base_validator.rb
-- lib/graphql/stitching/composer/supergraph_directives.rb
 - lib/graphql/stitching/composer/type_resolver_config.rb
 - lib/graphql/stitching/composer/validate_interfaces.rb
 - lib/graphql/stitching/composer/validate_type_resolvers.rb
+- lib/graphql/stitching/directives.rb
 - lib/graphql/stitching/executor.rb
 - lib/graphql/stitching/executor/root_source.rb
 - lib/graphql/stitching/executor/shaper.rb
@@ -177,6 +178,7 @@ files:
 - lib/graphql/stitching/request/skip_include.rb
 - lib/graphql/stitching/supergraph.rb
 - lib/graphql/stitching/supergraph/from_definition.rb
+- lib/graphql/stitching/supergraph/types.rb
 - lib/graphql/stitching/type_resolver.rb
 - lib/graphql/stitching/type_resolver/arguments.rb
 - lib/graphql/stitching/type_resolver/keys.rb