graphql-stitching 1.6.1 → 1.6.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: da2c14565c38d14e4e49f51ff2027f89a2ee4c0313102083c9ea3baadbcd02d4
-  data.tar.gz: eec311845ed143af3f8d598c22f2b6026a46d34868fd7546abfb585a8fed6ebc
+  metadata.gz: b6b2cc734796d7455701bcc5b376a8efb49534c43b7a75de53bc1f2e686bf54c
+  data.tar.gz: 449c09b94257de6ae720b4b7938c13b8881da9f1f8dc7684aabdc4c493b2c6d2
 SHA512:
-  metadata.gz: 87608b9f5391ec190e0d0f534e1a58447f056b37e37c3f569d908b2c7043d40ef38732b3bff6e4975d81d34b04bb84cd88f809b364d73aeade68675f8c35f35f
-  data.tar.gz: eb1e085ad36c36b52b0c871d9d8f3ff0ca5b6d29ff51c1ea6cd9564c0cdba8e554381615099a331426f4857b82049290287c79cc1338388a36027cb451aa3bb9
+  metadata.gz: 94345a14cc9bcee462854188b543a170b3dbd65cc948e55773e1a07357f47026f41018ea35eedbacc8647d8a92634be1f143d86543f0ea092f48ddb1281a86f5
+  data.tar.gz: ae7cb67b6f36ca209f327d43bd293fa6afc4e6a93e8e91e83f4acf2893b744831836959402cd236e789ade5602857bb39d484025ea58c7e16d19b9ec5eb69d67

data/lib/graphql/stitching/{supergraph/resolver_directive.rb → 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 @@ module GraphQL::Stitching
       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

data/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 @@ module GraphQL
 
         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 @@ module GraphQL
 
         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 @@ module GraphQL
           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

data/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

data/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,7 +16,10 @@ module GraphQL
       # @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
@@ -24,15 +27,14 @@ module GraphQL
         @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 @@ module GraphQL
             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 @@ module GraphQL
         @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

data/lib/graphql/stitching/type_resolver.rb

@@ -65,6 +65,10 @@ module GraphQL
           argument_types: arguments.map(&:to_type_definition).join(", "),
         }.tap(&:compact!)
       end
+
+      def inspect
+        as_json.to_json
+      end
     end
   end
 end

data/lib/graphql/stitching/version.rb

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

data/lib/graphql/stitching.rb

@@ -49,12 +49,6 @@ module GraphQL
       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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql-stitching
 version: !ruby/object:Gem::Version
-  version: 1.6.1
+  version: 1.6.2
 platform: ruby
 authors:
 - Greg MacWilliam
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-04-22 00:00:00.000000000 Z
+date: 2025-04-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: graphql
@@ -161,6 +161,7 @@ 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
@@ -175,10 +176,7 @@ files:
 - lib/graphql/stitching/request.rb
 - lib/graphql/stitching/request/skip_include.rb
 - lib/graphql/stitching/supergraph.rb
-- lib/graphql/stitching/supergraph/key_directive.rb
-- lib/graphql/stitching/supergraph/resolver_directive.rb
-- lib/graphql/stitching/supergraph/source_directive.rb
-- lib/graphql/stitching/supergraph/to_definition.rb
+- lib/graphql/stitching/supergraph/from_definition.rb
 - lib/graphql/stitching/type_resolver.rb
 - lib/graphql/stitching/type_resolver/arguments.rb
 - lib/graphql/stitching/type_resolver/keys.rb

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

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-module GraphQL::Stitching
-  class Supergraph
-    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
-  end
-end

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

@@ -1,12 +0,0 @@
-# frozen_string_literal: true
-
-module GraphQL::Stitching
-  class Supergraph
-    class SourceDirective < GraphQL::Schema::Directive
-      graphql_name "source"
-      locations FIELD_DEFINITION
-      argument :location, String, required: true
-      repeatable true
-    end
-  end
-end

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

@@ -1,164 +0,0 @@
-# frozen_string_literal: true
-require_relative "./key_directive"
-require_relative "./resolver_directive"
-require_relative "./source_directive"
-
-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 == 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 == 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 == 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
-
-    def to_definition
-      if @schema.directives[KeyDirective.graphql_name].nil?
-        @schema.directive(KeyDirective)
-      end
-      if @schema.directives[ResolverDirective.graphql_name].nil?
-        @schema.directive(ResolverDirective)
-      end
-      if @schema.directives[SourceDirective.graphql_name].nil?
-        @schema.directive(SourceDirective)
-      end
-
-      @schema.types.each do |type_name, type|
-        if resolvers_for_type = @resolvers.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|
-              params = { key: key, location: location }
-
-              unless has_directive?(type, KeyDirective.graphql_name, params)
-                type.directive(KeyDirective, **params)
-              end
-            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),
-            }
-
-            unless has_directive?(type, ResolverDirective.graphql_name, params)
-              type.directive(ResolverDirective, **params.tap(&:compact!))
-            end
-          end
-        end
-
-        next unless type.kind.fields?
-
-        type.fields.each do |field_name, field|
-          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|
-            params = { location: location }
-
-            unless has_directive?(field, SourceDirective.graphql_name, params)
-              field.directive(SourceDirective, **params)
-            end
-          end
-        end
-      end
-
-      @schema.to_definition
-    end
-
-    private
-
-    def has_directive?(element, directive_name, params)
-      existing = element.directives.find do |d|
-        kwargs = d.arguments.keyword_arguments
-        d.graphql_name == directive_name && params.all? { |k, v| kwargs[k] == v }
-      end
-
-      !existing.nil?
-    end
-  end
-end