graphql-stitching 0.3.3 → 0.3.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b07a54288795f5b321029340a61e97dd9209d395712dc9ac5921ebd5c52523a1
-  data.tar.gz: 83e4dea46c7b4ff7a3716c2936773893df58e732a50c36ee1a5af8e4e5cab4bd
+  metadata.gz: 0b8fbbdd8c300982092ee9297953f87e014420801e1a6058a49e36d5de8fb85b
+  data.tar.gz: 1fbd9b21161e8452a2fa55c4617ffabe8834c49e1b0635a58e17ed9b0cb43315
 SHA512:
-  metadata.gz: 831a54675315529b6bc1d489296a15325f88bcccbbb8f480c786641410de853989425591f4e60a6249ef123a3aa9e204780388925f2a027d758ac5594ca6c306
-  data.tar.gz: f66ab6dfc996aa9982f6c5d09e2bf98b5a5de8b85220ea839f854e53edd3f55144404b5ddff91f2681f7d8fee21071bb54f20265951424840c527b7203dd9ace
+  metadata.gz: 9eb747176cb0b39ced4ce35a10bab8f4a8e0b7448a5d6a9a74e8e74f484aba7f1bea46c1eff3ca3b118ee3be5fd2f8e7f5ebffb23dd5e6480a92abe620af9523
+  data.tar.gz: 64d935449b052d52b1068f22cc7df4b33608bb2b05bb5f8670da0e045f1c0faa06e44aa137acedab469312db5cda5144755a8d99b116a1c7ac09f809759ef198

data/lib/graphql/stitching/executor.rb

@@ -251,7 +251,7 @@ module GraphQL
 
         if @data && @data.length > 0
           result["data"] = raw ? @data : GraphQL::Stitching::Shaper.new(
-            schema: @supergraph.schema,
+            supergraph: @supergraph,
             request: @request,
           ).perform!(@data)
         end

data/lib/graphql/stitching/planner.rb

@@ -37,10 +37,11 @@ module GraphQL
         when "query"
           parent_type = @supergraph.schema.query
 
-          selections_by_location = @request.operation.selections.each_with_object({}) do |node, memo|
+          selections_by_location = {}
+          each_selection_in_type(parent_type, @request.operation.selections) do |node|
             locations = @supergraph.locations_by_type_and_field[parent_type.graphql_name][node.name] || SUPERGRAPH_LOCATIONS
-            memo[locations.first] ||= []
-            memo[locations.first] << node
+            selections_by_location[locations.first] ||= []
+            selections_by_location[locations.first] << node
           end
 
           selections_by_location.each do |location, selections|
@@ -50,14 +51,15 @@ module GraphQL
         when "mutation"
           parent_type = @supergraph.schema.mutation
 
-          location_groups = @request.operation.selections.each_with_object([]) do |node, memo|
+          location_groups = []
+          each_selection_in_type(parent_type, @request.operation.selections) do |node|
             next_location = @supergraph.locations_by_type_and_field[parent_type.graphql_name][node.name].first
 
-            if memo.none? || memo.last[:location] != next_location
-              memo << { location: next_location, selections: [] }
+            if location_groups.none? || location_groups.last[:location] != next_location
+              location_groups << { location: next_location, selections: [] }
             end
 
-            memo.last[:selections] << node
+            location_groups.last[:selections] << node
           end
 
           location_groups.reduce(0) do |after_key, group|
@@ -75,6 +77,27 @@ module GraphQL
         end
       end
 
+      def each_selection_in_type(parent_type, input_selections, &block)
+        input_selections.each do |node|
+          case node
+          when GraphQL::Language::Nodes::Field
+            yield(node)
+
+          when GraphQL::Language::Nodes::InlineFragment
+            next unless parent_type.graphql_name == node.type.name
+            each_selection_in_type(parent_type, node.selections, &block)
+
+          when GraphQL::Language::Nodes::FragmentSpread
+            fragment = @request.fragment_definitions[node.name]
+            next unless parent_type.graphql_name == fragment.type.name
+            each_selection_in_type(parent_type, fragment.selections, &block)
+
+          else
+            raise "Unexpected node of type #{node.class.name} in selection set."
+          end
+        end
+      end
+
       # adds an operation (data access) to the plan which maps a data selection to an insertion point.
       # note that planned operations are NOT always 1:1 with executed requests, as the executor can
       # frequently batch different insertion points with the same location into a single request.
@@ -98,11 +121,8 @@ module GraphQL
         # groupings coalesce similar operation parameters into a single operation
         # multiple operations per service may still occur with different insertion points,
         # but those will get query-batched together during execution.
-        grouping = String.new
-        grouping << after_key.to_s << "/" << location << "/" << parent_type.graphql_name
-        grouping = insertion_path.reduce(grouping) do |memo, segment|
-          memo << "/" << segment
-        end
+        grouping = String.new("#{after_key}/#{location}/#{parent_type.graphql_name}")
+        insertion_path.each { grouping << "/#{_1}" }
 
         if op = @operations_by_grouping[grouping]
           op.selections.concat(locale_selections)
@@ -155,7 +175,7 @@ module GraphQL
               next
             end
 
-            field_type = Util.named_type_for_field_node(@supergraph.schema, parent_type, node)
+            field_type = @supergraph.memoized_schema_fields(parent_type.graphql_name)[node.name].type.unwrap
             extract_node_variables(node, locale_variables)
 
             if Util.is_leaf_type?(field_type)
@@ -171,7 +191,7 @@ module GraphQL
           when GraphQL::Language::Nodes::InlineFragment
             next unless @supergraph.locations_by_type[node.type.name].include?(current_location)
 
-            fragment_type = @supergraph.schema.types[node.type.name]
+            fragment_type = @supergraph.memoized_schema_types[node.type.name]
             selection_set = extract_locale_selections(current_location, fragment_type, node.selections, insertion_path, after_key, locale_variables)
             locale_selections << node.merge(selections: selection_set)
             implements_fragments = true
@@ -180,7 +200,7 @@ module GraphQL
             fragment = @request.fragment_definitions[node.name]
             next unless @supergraph.locations_by_type[fragment.type.name].include?(current_location)
 
-            fragment_type = @supergraph.schema.types[fragment.type.name]
+            fragment_type = @supergraph.memoized_schema_types[fragment.type.name]
             selection_set = extract_locale_selections(current_location, fragment_type, fragment.selections, insertion_path, after_key, locale_variables)
             locale_selections << GraphQL::Language::Nodes::InlineFragment.new(type: fragment.type, selections: selection_set)
             implements_fragments = true
@@ -337,7 +357,7 @@ module GraphQL
         end
 
         if expanded_selections
-          @supergraph.schema.possible_types(parent_type).each do |possible_type|
+          @supergraph.memoized_schema_possible_types(parent_type.graphql_name).each do |possible_type|
             next unless @supergraph.locations_by_type[possible_type.graphql_name].include?(current_location)
 
             type_name = GraphQL::Language::Nodes::TypeName.new(name: possible_type.graphql_name)
@@ -354,7 +374,7 @@ module GraphQL
         @operations_by_grouping.each do |_grouping, op|
           next unless op.boundary
 
-          boundary_type = @supergraph.schema.types[op.boundary["type_name"]]
+          boundary_type = @supergraph.memoized_schema_types[op.boundary["type_name"]]
           next unless boundary_type.kind.abstract?
           next if boundary_type == op.parent_type
 

data/lib/graphql/stitching/shaper.rb

@@ -4,14 +4,14 @@
 module GraphQL
   module Stitching
     class Shaper
-      def initialize(schema:, request:)
-        @schema = schema
+      def initialize(supergraph:, request:)
+        @supergraph = supergraph
         @request = request
       end
 
       def perform!(raw)
-        root_type = @schema.public_send(@request.operation.operation_type)
-        resolve_object_scope(raw, root_type, @request.operation.selections)
+        @root_type = @supergraph.schema.root_type_for_operation(@request.operation.operation_type)
+        resolve_object_scope(raw, @root_type, @request.operation.selections, @root_type.graphql_name)
       end
 
       private
@@ -25,11 +25,14 @@ module GraphQL
         selections.each do |node|
           case node
           when GraphQL::Language::Nodes::Field
-            next if node.name.start_with?("__")
-
             field_name = node.alias || node.name
-            node_type = parent_type.fields[node.name].type
-            named_type = Util.named_type_for_field_node(@schema, parent_type, node)
+
+            next if introspection_field?(parent_type, node) do |is_root_typename|
+              raw_object[field_name] = @root_type.graphql_name if is_root_typename
+            end
+
+            node_type = @supergraph.memoized_schema_fields(parent_type.graphql_name)[node.name].type
+            named_type = node_type.unwrap
 
             raw_object[field_name] = if node_type.list?
               resolve_list_scope(raw_object[field_name], Util.unwrap_non_null(node_type), node.selections)
@@ -42,7 +45,7 @@ module GraphQL
             return nil if raw_object[field_name].nil? && node_type.non_null?
 
           when GraphQL::Language::Nodes::InlineFragment
-            fragment_type = @schema.types[node.type.name]
+            fragment_type = @supergraph.memoized_schema_types[node.type.name]
             next unless typename_in_type?(typename, fragment_type)
 
             result = resolve_object_scope(raw_object, fragment_type, node.selections, typename)
@@ -50,7 +53,7 @@ module GraphQL
 
           when GraphQL::Language::Nodes::FragmentSpread
             fragment = @request.fragment_definitions[node.name]
-            fragment_type = @schema.types[fragment.type.name]
+            fragment_type = @supergraph.memoized_schema_types[fragment.type.name]
             next unless typename_in_type?(typename, fragment_type)
 
             result = resolve_object_scope(raw_object, fragment_type, fragment.selections, typename)
@@ -93,9 +96,27 @@ module GraphQL
         resolved_list
       end
 
+      def introspection_field?(parent_type, node)
+        return false unless node.name.start_with?("__")
+        is_root = parent_type == @root_type
+
+        case node.name
+        when "__typename"
+          yield(is_root)
+          true
+        when "__schema", "__type"
+          is_root && @request.operation.operation_type == "query"
+        else
+          false
+        end
+      end
+
       def typename_in_type?(typename, type)
         return true if type.graphql_name == typename
-        type.kind.abstract? && @schema.possible_types(type).any? { _1.graphql_name == typename }
+
+        type.kind.abstract? && @supergraph.memoized_schema_possible_types(type.graphql_name).any? do |t|
+          t.graphql_name == typename
+        end
       end
     end
   end

data/lib/graphql/stitching/supergraph.rb

@@ -46,6 +46,8 @@ module GraphQL
         @boundaries = boundaries
         @possible_keys_by_type = {}
         @possible_keys_by_type_and_location = {}
+        @memoized_schema_possible_types = {}
+        @memoized_schema_fields = {}
 
         # add introspection types into the fields mapping
         @locations_by_type_and_field = INTROSPECTION_TYPES.each_with_object(fields) do |type_name, memo|
@@ -81,6 +83,28 @@ module GraphQL
         }
       end
 
+      def memoized_schema_types
+        @memoized_schema_types ||= @schema.types
+      end
+
+      def memoized_schema_possible_types(type_name)
+        @memoized_schema_possible_types[type_name] ||= @schema.possible_types(memoized_schema_types[type_name])
+      end
+
+      def memoized_schema_fields(type_name)
+        @memoized_schema_fields[type_name] ||= begin
+          fields = memoized_schema_types[type_name].fields
+          fields["__typename"] = @schema.introspection_system.dynamic_field(name: "__typename")
+
+          if type_name == @schema.query.graphql_name
+            fields["__schema"] = @schema.introspection_system.entry_point(name: "__schema")
+            fields["__type"] = @schema.introspection_system.entry_point(name: "__type")
+          end
+
+          fields
+        end
+      end
+
       def execute_at_location(location, source, variables, context)
         executable = executables[location]
 

data/lib/graphql/stitching/util.rb

@@ -37,15 +37,6 @@ module GraphQL
         structure
       end
 
-      # gets a named type for a field node, including hidden root introspections
-      def self.named_type_for_field_node(schema, parent_type, node)
-        if node.name == "__schema" && parent_type == schema.query
-          schema.types["__Schema"]
-        else
-          parent_type.fields[node.name].type.unwrap
-        end
-      end
-
       # expands interfaces and unions to an array of their memberships
       # like `schema.possible_types`, but includes child interfaces
       def self.expand_abstract_type(schema, parent_type)

data/lib/graphql/stitching/version.rb

@@ -2,6 +2,6 @@
 
 module GraphQL
   module Stitching
-    VERSION = "0.3.3"
+    VERSION = "0.3.4"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql-stitching
 version: !ruby/object:Gem::Version
-  version: 0.3.3
+  version: 0.3.4
 platform: ruby
 authors:
 - Greg MacWilliam
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-03-24 00:00:00.000000000 Z
+date: 2023-03-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: graphql