Restore AlwaysVisible (#171)

Author: gmac

lib/graphql/stitching.rb

@@ -49,12 +49,6 @@ def digest(&block)
       def stitch_directive
         @stitch_directive ||= "stitch"
       end
-
-      # Names of stitching directives to omit from the composed supergraph.
-      # @returns [Array<String>] list of stitching directive names.
-      def stitching_directive_names
-        [stitch_directive]
-      end
     end
   end
 end

lib/graphql/stitching/composer.rb

@@ -1,6 +1,7 @@
 # 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"
@@ -82,9 +83,16 @@ def perform(locations_input)
 
         schemas, executables = prepare_locations_input(locations_input)
 
+        directives_to_omit = [
+          GraphQL::Stitching.stitch_directive,
+          KeyDirective.graphql_name,
+          ResolverDirective.graphql_name,
+          SourceDirective.graphql_name,
+        ]
+
         # "directive_name" => "location" => subgraph_directive
         @subgraph_directives_by_name_and_location = schemas.each_with_object({}) do |(location, schema), memo|
-          (schema.directives.keys - schema.default_directives.keys - GraphQL::Stitching.stitching_directive_names).each do |directive_name|
+          (schema.directives.keys - schema.default_directives.keys - directives_to_omit).each do |directive_name|
             memo[directive_name] ||= {}
             memo[directive_name][location] = schema.directives[directive_name]
           end
@@ -154,25 +162,26 @@ def perform(locations_input)
 
         builder = self
         schema = Class.new(GraphQL::Schema) do
+          object_types = schema_types.values.select { |t| t.respond_to?(:kind) && t.kind.object? }
           add_type_and_traverse(schema_types.values, root: false)
-          orphan_types(schema_types.values.select { |t| t.respond_to?(:kind) && t.kind.object? })
+          orphan_types(object_types)
           query schema_types[builder.query_name]
           mutation schema_types[builder.mutation_name]
           subscription schema_types[builder.subscription_name]
           directives builder.schema_directives.values
 
+          object_types.each do |t|
+            t.interfaces.each { _1.orphan_types(t) }
+          end
+
           own_orphan_types.clear
         end
 
         select_root_field_locations(schema)
         expand_abstract_resolvers(schema, schemas)
+        apply_supergraph_directives(schema, @resolver_map, @field_map)
 
-        supergraph = Supergraph.new(
-          schema: schema,
-          fields: @field_map,
-          resolvers: @resolver_map,
-          executables: executables,
-        )
+        supergraph = Supergraph.from_definition(schema, executables: executables)
 
         COMPOSITION_VALIDATORS.each do |validator_class|
           validator_class.new.perform(supergraph, self)
@@ -670,6 +679,72 @@ def build_enum_usage_map(schemas)
           memo[enum_name] << :write
         end
       end
+
+      def apply_supergraph_directives(schema, resolvers_by_type_name, locations_by_type_and_field)
+        schema_directives = {}
+        schema.types.each do |type_name, type|
+          if resolvers_for_type = resolvers_by_type_name.dig(type_name)
+            # Apply key directives for each unique type/key/location
+            # (this allows keys to be composite selections and/or omitted from the supergraph schema)
+            keys_for_type = resolvers_for_type.each_with_object({}) do |resolver, memo|
+              memo[resolver.key.to_definition] ||= Set.new
+              memo[resolver.key.to_definition].merge(resolver.key.locations)
+            end
+  
+            keys_for_type.each do |key, locations|
+              locations.each do |location|
+                schema_directives[KeyDirective.graphql_name] ||= KeyDirective
+                type.directive(KeyDirective, key: key, location: location)
+              end
+            end
+  
+            # Apply resolver directives for each unique query resolver
+            resolvers_for_type.each do |resolver|
+              params = {
+                location: resolver.location,
+                field: resolver.field,
+                list: resolver.list? || nil,
+                key: resolver.key.to_definition,
+                arguments: resolver.arguments.map(&:to_definition).join(", "),
+                argument_types: resolver.arguments.map(&:to_type_definition).join(", "),
+                type_name: (resolver.type_name if resolver.type_name != type_name),
+              }
+  
+              schema_directives[ResolverDirective.graphql_name] ||= ResolverDirective
+              type.directive(ResolverDirective, **params.tap(&:compact!))
+            end
+          end
+  
+          next unless type.kind.fields? && !type.introspection?
+  
+          type.fields.each do |field_name, field|
+            if field.owner != type
+              # make a local copy of fields inherited from an interface
+              # to assure that source attributions reflect the object, not the interface.
+              field = type.field(
+                field.graphql_name,
+                description: field.description,
+                deprecation_reason: field.deprecation_reason,
+                type: Util.unwrap_non_null(field.type),
+                null: !field.type.non_null?,
+                connection: false,
+                camelize: false,
+              )
+            end
+            
+            locations_for_field = locations_by_type_and_field.dig(type_name, field_name)
+            next if locations_for_field.nil?
+  
+            # 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)
+            end
+          end
+        end
+        
+        schema_directives.each_value { |directive_class| schema.directive(directive_class) }
+      end
     end
   end
 end

lib/graphql/stitching/supergraph/resolver_directive.rb renamed to lib/graphql/stitching/composer/supergraph_directives.rb

@@ -1,7 +1,15 @@
 # frozen_string_literal: true
 
 module GraphQL::Stitching
-  class Supergraph
+  class Composer
+    class KeyDirective < GraphQL::Schema::Directive
+      graphql_name "key"
+      locations OBJECT, INTERFACE, UNION
+      argument :key, String, required: true
+      argument :location, String, required: true
+      repeatable true
+    end
+
     class ResolverDirective < GraphQL::Schema::Directive
       graphql_name "resolver"
       locations OBJECT, INTERFACE, UNION
@@ -14,5 +22,12 @@ class ResolverDirective < GraphQL::Schema::Directive
       argument :type_name, String, required: false
       repeatable true
     end
+    
+    class SourceDirective < GraphQL::Schema::Directive
+      graphql_name "source"
+      locations FIELD_DEFINITION
+      argument :location, String, required: true
+      repeatable true
+    end
   end
 end

lib/graphql/stitching/supergraph.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative "supergraph/to_definition"
+require_relative "supergraph/from_definition"
 
 module GraphQL
   module Stitching
@@ -16,23 +16,25 @@ class Supergraph
       # @return [Hash<String, Executable>] a map of executable resources by location.
       attr_reader :executables
 
-      attr_reader :resolvers, :locations_by_type_and_field
+      attr_reader :resolvers
+      attr_reader :memoized_schema_types
+      attr_reader :memoized_introspection_types
+      attr_reader :locations_by_type_and_field
 
       def initialize(schema:, fields: {}, resolvers: {}, executables: {})
         @schema = schema
         @resolvers = resolvers
         @resolvers_by_version = nil
         @fields_by_type_and_location = nil
         @locations_by_type = nil
-        @memoized_introspection_types = nil
+        @memoized_introspection_types = @schema.introspection_system.types
+        @memoized_schema_types = @schema.types
         @memoized_schema_fields = {}
-        @memoized_schema_types = nil
         @possible_keys_by_type = {}
         @possible_keys_by_type_and_location = {}
-        @static_validator = nil
 
         # add introspection types into the fields mapping
-        @locations_by_type_and_field = memoized_introspection_types.each_with_object(fields) do |(type_name, type), memo|
+        @locations_by_type_and_field = @memoized_introspection_types.each_with_object(fields) do |(type_name, type), memo|
           next unless type.kind.fields?
 
           memo[type_name] = type.fields.keys.each_with_object({}) do |field_name, m|
@@ -46,6 +48,12 @@ def initialize(schema:, fields: {}, resolvers: {}, executables: {})
             memo[location.to_s] = executable
           end
         end.freeze
+
+        @schema.use(GraphQL::Schema::AlwaysVisible)
+      end
+
+      def to_definition
+        @schema.to_definition
       end
 
       def resolvers_by_version
@@ -62,17 +70,9 @@ def locations
         @executables.keys.reject { _1 == SUPERGRAPH_LOCATION }
       end
 
-      def memoized_introspection_types
-        @memoized_introspection_types ||= schema.introspection_system.types
-      end
-
-      def memoized_schema_types
-        @memoized_schema_types ||= @schema.types
-      end
-
       def memoized_schema_fields(type_name)
         @memoized_schema_fields[type_name] ||= begin
-          fields = memoized_schema_types[type_name].fields
+          fields = @memoized_schema_types[type_name].fields
           @schema.introspection_system.dynamic_fields.each do |field|
             fields[field.name] ||= field # adds __typename
           end

lib/graphql/stitching/supergraph/from_definition.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module GraphQL::Stitching
+  class Supergraph
+    class << self
+      def validate_executable!(location, executable)
+        return true if executable.is_a?(Class) && executable <= GraphQL::Schema
+        return true if executable && executable.respond_to?(:call)
+        raise StitchingError, "Invalid executable provided for location `#{location}`."
+      end
+
+      def from_definition(schema, executables:)
+        schema = GraphQL::Schema.from_definition(schema) if schema.is_a?(String)
+        field_map = {}
+        resolver_map = {}
+        possible_locations = {}
+
+        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
+
+            kwargs = directive.arguments.keyword_arguments
+            memo[kwargs[:key]] ||= []
+            memo[kwargs[:key]] << kwargs[:location]
+          end
+
+          key_definitions = locations_by_key.each_with_object({}) do |(key, locations), memo|
+            memo[key] = TypeResolver.parse_key(key, locations)
+          end
+
+          # Collect/build resolver definitions for each type
+          type.directives.each do |directive|
+            next unless directive.graphql_name == Composer::ResolverDirective.graphql_name
+
+            kwargs = directive.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
+
+          next unless type.kind.fields?
+
+          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
+
+              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
+          end
+        end
+
+        executables = possible_locations.keys.each_with_object({}) do |location, memo|
+          executable = executables[location] || executables[location.to_sym]
+          if validate_executable!(location, executable)
+            memo[location] = executable
+          end
+        end
+
+        new(
+          schema: schema,
+          fields: field_map,
+          resolvers: resolver_map,
+          executables: executables,
+        )
+      end
+    end
+  end
+end