graphql-stitching 0.3.0 → 0.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8f7587a903fe54feeffe79deb25fdcf341f13af67b46f896003dfdba861cb614
-  data.tar.gz: 191ff2274244d23b16325579792fd07310bf5b3fc3cc1a2b20e7b30305456851
+  metadata.gz: 33a2615122207bdf93a7df873fe1efe7a7f3c13050f59dabc6e85becd75cf96e
+  data.tar.gz: 9f203624ab5c26a3cb6ab4710759ef7cb76c1890fff8f4849ab31404875fe79a
 SHA512:
-  metadata.gz: 7fd408963db10a7bfdfc272987a793353a190a191eb5de264a1a6a0ccd7e80293605bb57e85c70c52f66a3cd646b966930741b938ca231146f527704b524f0a1
-  data.tar.gz: 1857a8492545cc4d7da64c541c897bb14e898c391edf271baf54a5e39369d8f387d80500c40fc591726c2dcb06fcce3f1164a9680f266e9a22494da577076648
+  metadata.gz: ad1afa71d6525ea79857106eca6c347f77fab8141dd9a504f3da1a6631f598fe7fb154bc446e228e420fa46dff993140ff568fc3dc94af7a76f0cf29da550896
+  data.tar.gz: 2632af6a1347f1fb6513c79781c3959aacdd879583519cb31e69834a48f2ae70cafdb778d6915713d0d19bf535a67cac55763377cc27da0795b80ed6abc298d4

data/.gitignore

@@ -25,6 +25,8 @@ Gemfile.lock
 .dat*
 .repl_history
 build/
+node_modules/
+package-lock.json
 *.bridgesupport
 build-iPhoneOS/
 build-iPhoneSimulator/

data/README.md

@@ -32,7 +32,7 @@ require "graphql/stitching"
 
 ## Usage
 
-The quickest way to start is to use the provided [`Gateway`](./docs/gateway.md) component that assembles a stitched graph ready to execute requests:
+The quickest way to start is to use the provided [`Gateway`](./docs/gateway.md) component that wraps a stitched graph in an executable workflow with [caching hooks](./docs/gateway.md#cache-hooks):
 
 ```ruby
 movies_schema = <<~GRAPHQL
@@ -305,13 +305,13 @@ class MyExecutable
 end
 ```
 
-A [Supergraph](./docs/supergraph.md) is composed with executable resource provided for each location. Any location that omits the `executable` option will use the provided `schema` as the default executable:
+A [Supergraph](./docs/supergraph.md) is composed with executable resources provided for each location. Any location that omits the `executable` option will use the provided `schema` as its default executable:
 
 ```ruby
 supergraph = GraphQL::Stitching::Composer.new.perform({
   first: {
     schema: FirstSchema,
-    # executable: ^^^^^ delegates to FirstSchema,
+    # executable:^^^^^^ delegates to FirstSchema,
   },
   second: {
     schema: SecondSchema,

data/lib/graphql/stitching/composer/validate_boundaries.rb

@@ -33,8 +33,9 @@ module GraphQL
         # only one boundary allowed per type/location/key
         boundaries_by_location_and_key = boundaries.each_with_object({}) do |boundary, memo|
           if memo.dig(boundary["location"], boundary["selection"])
-            raise Composer::ValidationError, "Multiple boundary queries for `#{type.graphql_name}.#{boundary["selection"]}` found in #{boundary["location"]}.
-            Limit one boundary query per type and key in each location. Abstract boundaries provide all possible types."
+            raise Composer::ValidationError, "Multiple boundary queries for `#{type.graphql_name}.#{boundary["selection"]}` "\
+              "found in #{boundary["location"]}. Limit one boundary query per type and key in each location. "\
+              "Abstract boundaries provide all possible types."
           end
           memo[boundary["location"]] ||= {}
           memo[boundary["location"]][boundary["selection"]] = boundary
@@ -60,8 +61,8 @@ module GraphQL
           remote_locations = bidirectional_access_locations.reject { _1 == location }
           paths = ctx.route_type_to_locations(type.graphql_name, location, remote_locations)
           if paths.length != remote_locations.length || paths.any? { |_loc, path| path.nil? }
-            raise Composer::ValidationError, "Cannot route `#{type.graphql_name}` boundaries in #{location} to all other locations.
-            All locations must provide a boundary accessor that uses a conjoining key."
+            raise Composer::ValidationError, "Cannot route `#{type.graphql_name}` boundaries in #{location} to all other locations. "\
+              "All locations must provide a boundary accessor that uses a conjoining key."
           end
         end
       end
@@ -80,8 +81,8 @@ module GraphQL
 
         subschema_types_by_location.each do |location, subschema_type|
           if subschema_type.fields.keys.sort != expected_fields
-            raise Composer::ValidationError, "Shared type `#{type.graphql_name}` must have consistent fields across locations,
-            or else define boundary queries so that its unique fields may be accessed remotely."
+            raise Composer::ValidationError, "Shared type `#{type.graphql_name}` must have consistent fields across locations, "\
+              "or else define boundary queries so that its unique fields may be accessed remotely."
           end
         end
       end

data/lib/graphql/stitching/composer/validate_interfaces.rb

@@ -4,19 +4,47 @@ module GraphQL
   module Stitching
     class Composer::ValidateInterfaces < Composer::BaseValidator
 
+      # For each composed interface, check the interface against each possible type
+      # to assure that intersecting fields have compatible types, structures, and nullability.
+      # Verifies compatibility of types that inherit interface contracts through merging.
       def perform(supergraph, composer)
-        # @todo
-        # Validate all supergraph interface fields
-        # match possible types in all locations...
-        # - Traverse supergraph types (supergraph.types)
-        # - For each interface (.kind.interface?), get possible types (Util.get_possible_types)
-        # - For each possible type, traverse type candidates (composer.subschema_types_by_name_and_location)
-        # - For each type candidate, compare interface fields to type candidate fields
-        # - For each type candidate field that matches an interface field...
-        #   - Named types must match
-        #   - List structures must match
-        #   - Nullabilities must be >= interface field
-        # - It's OKAY if a type candidate does not implement the full interface
+        supergraph.schema.types.each do |type_name, interface_type|
+          next unless interface_type.kind.interface?
+
+          supergraph.schema.possible_types(interface_type).each do |possible_type|
+            interface_type.fields.each do |field_name, interface_field|
+              # graphql-ruby will dynamically apply interface fields on a type implementation,
+              # so check the delegation map to assure that all materialized fields have resolver locations.
+              unless supergraph.locations_by_type_and_field[possible_type.graphql_name][field_name]&.any?
+                raise Composer::ValidationError, "Type #{possible_type.graphql_name} does not implement a `#{field_name}` field in any location, "\
+                  "which is required by interface #{interface_type.graphql_name}."
+              end
+
+              intersecting_field = possible_type.fields[field_name]
+              interface_type_structure = Util.flatten_type_structure(interface_field.type)
+              possible_type_structure = Util.flatten_type_structure(intersecting_field.type)
+
+              if possible_type_structure.length != interface_type_structure.length
+                raise Composer::ValidationError, "Incompatible list structures between field #{possible_type.graphql_name}.#{field_name} of type "\
+                  "#{intersecting_field.type.to_type_signature} and interface #{interface_type.graphql_name}.#{field_name} of type #{interface_field.type.to_type_signature}."
+              end
+
+              interface_type_structure.each_with_index do |interface_struct, index|
+                possible_struct = possible_type_structure[index]
+
+                if possible_struct[:name] != interface_struct[:name]
+                  raise Composer::ValidationError, "Incompatible named types between field #{possible_type.graphql_name}.#{field_name} of type "\
+                    "#{intersecting_field.type.to_type_signature} and interface #{interface_type.graphql_name}.#{field_name} of type #{interface_field.type.to_type_signature}."
+                end
+
+                if possible_struct[:null] && !interface_struct[:null]
+                  raise Composer::ValidationError, "Incompatible nullability between field #{possible_type.graphql_name}.#{field_name} of type "\
+                    "#{intersecting_field.type.to_type_signature} and interface #{interface_type.graphql_name}.#{field_name} of type #{interface_field.type.to_type_signature}."
+                end
+              end
+            end
+          end
+        end
       end
 
     end

data/lib/graphql/stitching/composer.rb

@@ -77,7 +77,7 @@ module GraphQL
         schema_types = @subschema_types_by_name_and_location.each_with_object({}) do |(type_name, types_by_location), memo|
           kinds = types_by_location.values.map { _1.kind.name }.uniq
 
-          unless kinds.all? { _1 == kinds.first }
+          if kinds.length > 1
             raise ComposerError, "Cannot merge different kinds for `#{type_name}`. Found: #{kinds.join(", ")}."
           end
 
@@ -96,7 +96,7 @@ module GraphQL
           when "INPUT_OBJECT"
             build_input_object_type(type_name, types_by_location)
           else
-            raise ComposerError, "Unexpected kind encountered for `#{type_name}`. Found: #{kind}."
+            raise ComposerError, "Unexpected kind encountered for `#{type_name}`. Found: #{kinds.first}."
           end
         end
 
@@ -307,12 +307,13 @@ module GraphQL
         fields_by_name_location.each do |field_name, fields_by_location|
           value_types = fields_by_location.values.map(&:type)
 
+          type = merge_value_types(type_name, value_types, field_name: field_name)
           schema_field = owner.field(
             field_name,
             description: merge_descriptions(type_name, fields_by_location, field_name: field_name),
             deprecation_reason: merge_deprecations(type_name, fields_by_location, field_name: field_name),
-            type: merge_value_types(type_name, value_types, field_name: field_name),
-            null: !value_types.all?(&:non_null?),
+            type: Util.unwrap_non_null(type),
+            null: !type.non_null?,
             camelize: false,
           )
 
@@ -345,12 +346,13 @@ module GraphQL
           # Getting double args sometimes... why?
           return if owner.arguments.any? { _1.first == argument_name }
 
+          type = merge_value_types(type_name, value_types, argument_name: argument_name, field_name: field_name)
           schema_argument = owner.argument(
             argument_name,
             description: merge_descriptions(type_name, arguments_by_location, argument_name: argument_name, field_name: field_name),
             deprecation_reason: merge_deprecations(type_name, arguments_by_location, argument_name: argument_name, field_name: field_name),
-            type: merge_value_types(type_name, value_types, argument_name: argument_name, field_name: field_name),
-            required: value_types.any?(&:non_null?),
+            type: Util.unwrap_non_null(type),
+            required: type.non_null?,
             camelize: false,
           )
 
@@ -401,37 +403,32 @@ module GraphQL
 
       def merge_value_types(type_name, type_candidates, field_name: nil, argument_name: nil)
         path = [type_name, field_name, argument_name].compact.join(".")
-        named_types = type_candidates.map { _1.unwrap.graphql_name }.uniq
+        alt_structures = type_candidates.map { Util.flatten_type_structure(_1) }
+        basis_structure = alt_structures.shift
 
-        unless named_types.all? { _1 == named_types.first }
-          raise ComposerError, "Cannot compose mixed types at `#{path}`. Found: #{named_types.join(", ")}."
-        end
-
-        type = GraphQL::Schema::BUILT_IN_TYPES.fetch(named_types.first, build_type_binding(named_types.first))
-        list_structures = type_candidates.map { Util.get_list_structure(_1) }
-
-        if list_structures.any?(&:any?)
-          if list_structures.any? { _1.length != list_structures.first.length }
+        alt_structures.each do |alt_structure|
+          if alt_structure.length != basis_structure.length
             raise ComposerError, "Cannot compose mixed list structures at `#{path}`."
           end
 
-          list_structures.each(&:reverse!)
-          list_structures.first.each_with_index do |current, index|
-            # input arguments use strongest nullability, readonly fields use weakest
-            non_null = list_structures.public_send(argument_name ? :any? : :all?) do |list_structure|
-              list_structure[index].start_with?("non_null")
-            end
-
-            case current
-            when "list", "non_null_list"
-              type = type.to_list_type
-              type = type.to_non_null_type if non_null
-            when "element", "non_null_element"
-              type = type.to_non_null_type if non_null
-            end
+          if alt_structure.last[:name] != basis_structure.last[:name]
+            raise ComposerError, "Cannot compose mixed types at `#{path}`."
           end
         end
 
+        type = GraphQL::Schema::BUILT_IN_TYPES.fetch(
+          basis_structure.last[:name],
+          build_type_binding(basis_structure.last[:name])
+        )
+
+        basis_structure.reverse!.each_with_index do |basis, index|
+          rev_index = basis_structure.length - index - 1
+          non_null = alt_structures.each_with_object([!basis[:null]]) { |s, m| m << !s[rev_index][:null] }
+
+          type = type.to_list_type if basis[:list]
+          type = type.to_non_null_type if argument_name ? non_null.any? : non_null.all?
+        end
+
         type
       end
 
@@ -459,7 +456,7 @@ module GraphQL
         types_by_location.each do |location, type_candidate|
           type_candidate.fields.each do |field_name, field_candidate|
             boundary_type_name = field_candidate.type.unwrap.graphql_name
-            boundary_list = Util.get_list_structure(field_candidate.type)
+            boundary_structure = Util.flatten_type_structure(field_candidate.type)
 
             field_candidate.directives.each do |directive|
               next unless directive.graphql_name == GraphQL::Stitching.stitch_directive
@@ -482,8 +479,8 @@ module GraphQL
                 raise ComposerError, "Invalid boundary argument `#{argument_name}` for #{type_name}.#{field_name}."
               end
 
-              argument_list = Util.get_list_structure(argument.type)
-              if argument_list.length != boundary_list.length
+              argument_structure = Util.flatten_type_structure(argument.type)
+              if argument_structure.length != boundary_structure.length
                 raise ComposerError, "Mismatched input/output for #{type_name}.#{field_name}.#{argument_name} boundary. Arguments must map directly to results."
               end
 
@@ -493,7 +490,7 @@ module GraphQL
                 "selection" => key_selections[0].name,
                 "field" => field_candidate.name,
                 "arg" => argument_name,
-                "list" => boundary_list.any?,
+                "list" => boundary_structure.first[:list],
                 "type_name" => boundary_type_name,
               }
             end

data/lib/graphql/stitching/gateway.rb

@@ -35,9 +35,9 @@ module GraphQL
           return error_result(validation_errors) if validation_errors.any?
         end
 
-        request.prepare!
-
         begin
+          request.prepare!
+
           plan = fetch_plan(request) do
             GraphQL::Stitching::Planner.new(
               supergraph: @supergraph,

data/lib/graphql/stitching/planner.rb

@@ -20,13 +20,11 @@ module GraphQL
       end
 
       def operations
-        ops = @operations_by_grouping.values
-        ops.sort_by!(&:key)
-        ops
+        @operations_by_grouping.values.sort_by!(&:key)
       end
 
       def to_h
-        { "ops" => operations.map(&:to_h) }
+        { "ops" => operations.map!(&:to_h) }
       end
 
       private
@@ -53,18 +51,16 @@ module GraphQL
 
         when "mutation"
           parent_type = @supergraph.schema.mutation
-          location_groups = []
 
-          @request.operation.selections.reduce(nil) do |last_location, node|
+          location_groups = @request.operation.selections.each_with_object([]) do |node, memo|
             # root fields currently just delegate to the last location that defined them; this should probably be smarter
             next_location = @supergraph.locations_by_type_and_field[parent_type.graphql_name][node.name].last
 
-            if next_location != last_location
-              location_groups << { location: next_location, selections: [] }
+            if memo.none? || memo.last[:location] != next_location
+              memo << { location: next_location, selections: [] }
             end
 
-            location_groups.last[:selections] << node
-            next_location
+            memo.last[:selections] << node
           end
 
           location_groups.reduce(0) do |after_key, group|
@@ -144,7 +140,7 @@ module GraphQL
         implements_fragments = false
 
         if parent_type.kind.interface?
-          expand_interface_selections(current_location, parent_type, input_selections)
+          input_selections = expand_interface_selections(current_location, parent_type, input_selections)
         end
 
         input_selections.each do |node|
@@ -252,7 +248,7 @@ module GraphQL
             possible_locations = possible_locations_by_field[node.name]
             preferred_location_score = 0
 
-            # hill climbing selects highest scoring locations to use
+            # hill-climb to select highest scoring location for each field
             preferred_location = possible_locations.reduce(possible_locations.first) do |best_location, possible_location|
               score = selections_by_location[possible_location] ? remote_selections.length : 0
               score += location_weights.fetch(possible_location, 0)
@@ -270,6 +266,8 @@ module GraphQL
           end
         end
 
+        # route from current location to target locations via boundary queries,
+        # then translate those routes into planner operations
         routes = @supergraph.route_type_to_locations(parent_type.graphql_name, current_location, selections_by_location.keys)
         routes.values.each_with_object({}) do |route, ops_by_location|
           route.reduce(nil) do |parent_op, boundary|
@@ -328,8 +326,8 @@ module GraphQL
         local_interface_fields = @supergraph.fields_by_type_and_location[parent_type.graphql_name][current_location]
 
         expanded_selections = nil
-        input_selections.reject! do |node|
-          if node.is_a?(GraphQL::Language::Nodes::Field) && !local_interface_fields.include?(node.name)
+        input_selections = input_selections.reject do |node|
+          if node.is_a?(GraphQL::Language::Nodes::Field) && node.name != "__typename" && !local_interface_fields.include?(node.name)
             expanded_selections ||= []
             expanded_selections << node
             true
@@ -344,6 +342,8 @@ module GraphQL
             input_selections << GraphQL::Language::Nodes::InlineFragment.new(type: type_name, selections: expanded_selections)
           end
         end
+
+        input_selections
       end
 
       # expand concrete type selections into typed fragments when sending to abstract boundaries

data/lib/graphql/stitching/planner_operation.rb

@@ -3,6 +3,8 @@
 module GraphQL
   module Stitching
     class PlannerOperation
+      LANGUAGE_PRINTER = GraphQL::Language::Printer.new
+
       attr_reader :key, :location, :parent_type, :type_condition, :operation_type, :insertion_path
       attr_accessor :after_key, :selections, :variables, :boundary
 
@@ -32,12 +34,12 @@ module GraphQL
 
       def selection_set
         op = GraphQL::Language::Nodes::OperationDefinition.new(selections: @selections)
-        GraphQL::Language::Printer.new.print(op).gsub!(/\s+/, " ").strip!
+        LANGUAGE_PRINTER.print(op).gsub!(/\s+/, " ").strip!
       end
 
       def variable_set
         @variables.each_with_object({}) do |(variable_name, value_type), memo|
-          memo[variable_name] = GraphQL::Language::Printer.new.print(value_type)
+          memo[variable_name] = LANGUAGE_PRINTER.print(value_type)
         end
       end
 

data/lib/graphql/stitching/shaper.rb

@@ -42,15 +42,16 @@ module GraphQL
             return nil if raw_object[field_name].nil? && node_type.non_null?
 
           when GraphQL::Language::Nodes::InlineFragment
-            next unless typename == node.type.name
             fragment_type = @schema.types[node.type.name]
+            next unless typename_in_type?(typename, fragment_type)
+
             result = resolve_object_scope(raw_object, fragment_type, node.selections, typename)
             return nil if result.nil?
 
           when GraphQL::Language::Nodes::FragmentSpread
             fragment = @request.fragment_definitions[node.name]
             fragment_type = @schema.types[fragment.type.name]
-            next unless typename == fragment_type.graphql_name
+            next unless typename_in_type?(typename, fragment_type)
 
             result = resolve_object_scope(raw_object, fragment_type, fragment.selections, typename)
             return nil if result.nil?
@@ -91,6 +92,11 @@ module GraphQL
 
         resolved_list
       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 }
+      end
     end
   end
 end

data/lib/graphql/stitching/util.rb

@@ -10,12 +10,33 @@ module GraphQL
 
       # strips non-null wrappers from a type
       def self.unwrap_non_null(type)
-        while type.is_a?(GraphQL::Schema::NonNull)
-          type = type.of_type
-        end
+        type = type.of_type while type.non_null?
         type
       end
 
+      # builds a single-dimensional representation of a wrapped type structure
+      def self.flatten_type_structure(type)
+        structure = []
+
+        while type.list?
+          structure << {
+            list: true,
+            null: !type.non_null?,
+            name: nil,
+          }
+
+          type = unwrap_non_null(type).of_type
+        end
+
+        structure << {
+          list: false,
+          null: !type.non_null?,
+          name: type.unwrap.graphql_name,
+        }
+
+        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
@@ -40,25 +61,6 @@ module GraphQL
         end
         result.uniq
       end
-
-      # gets a deep structural description of a list value type
-      def self.get_list_structure(type)
-        structure = []
-        previous = nil
-        while type.respond_to?(:of_type)
-          if type.is_a?(GraphQL::Schema::List)
-            structure.push(previous.is_a?(GraphQL::Schema::NonNull) ? "non_null_list" : "list")
-          end
-          if structure.any?
-            previous = type
-            if !type.of_type.respond_to?(:of_type)
-              structure.push(previous.is_a?(GraphQL::Schema::NonNull) ? "non_null_element" : "element")
-            end
-          end
-          type = type.of_type
-        end
-        structure
-      end
     end
   end
 end

data/lib/graphql/stitching/version.rb

@@ -2,6 +2,6 @@
 
 module GraphQL
   module Stitching
-    VERSION = "0.3.0"
+    VERSION = "0.3.2"
   end
 end

metadata

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