graphql-stitching 0.1.0 → 0.2.2

data/lib/graphql/stitching/shaper.rb

@@ -4,14 +4,14 @@
 module GraphQL
   module Stitching
     class Shaper
-      def initialize(schema:, document:)
+      def initialize(schema:, request:)
         @schema = schema
-        @document = document
+        @request = request
       end
 
       def perform!(raw)
-        raw["data"] = resolve_object_scope(raw["data"], @schema.query, @document.operation.selections)
-        raw
+        root_type = @schema.public_send(@request.operation.operation_type)
+        resolve_object_scope(raw, root_type, @request.operation.selections)
       end
 
       private
@@ -29,7 +29,7 @@ module GraphQL
 
             field_name = node.alias || node.name
             node_type = parent_type.fields[node.name].type
-            named_type = Util.get_named_type_for_field_node(@schema, parent_type, node)
+            named_type = Util.named_type_for_field_node(@schema, parent_type, node)
 
             raw_object[field_name] = if node_type.list?
               resolve_list_scope(raw_object[field_name], Util.unwrap_non_null(node_type), node.selections)
@@ -48,7 +48,7 @@ module GraphQL
             return nil if result.nil?
 
           when GraphQL::Language::Nodes::FragmentSpread
-            fragment = @document.fragment_definitions[node.name]
+            fragment = @request.fragment_definitions[node.name]
             fragment_type = @schema.types[fragment.type.name]
             next unless typename == fragment_type.graphql_name
 
@@ -67,7 +67,7 @@ module GraphQL
         return nil if raw_list.nil?
 
         next_node_type = Util.unwrap_non_null(current_node_type).of_type
-        named_type = Util.get_named_type(next_node_type)
+        named_type = next_node_type.unwrap
         contains_null = false
 
         resolved_list = raw_list.map! do |raw_list_element|

data/lib/graphql/stitching/supergraph.rb

@@ -29,6 +29,7 @@ module GraphQL
           end
         end
 
+        @possible_keys_by_type = {}
         @possible_keys_by_type_and_location = {}
         @executables = { LOCATION => @schema }.merge!(executables)
       end
@@ -57,31 +58,33 @@ module GraphQL
       def assign_executable(location, executable = nil, &block)
         executable ||= block
         unless executable.is_a?(Class) && executable <= GraphQL::Schema
-          raise "A client or block handler must be provided." unless executable
-          raise "A client must be callable" unless executable.respond_to?(:call)
+          raise StitchingError, "A client or block handler must be provided." unless executable
+          raise StitchingError, "A client must be callable" unless executable.respond_to?(:call)
         end
         @executables[location] = executable
       end
 
-      def execute_at_location(location, query, variables)
+      def execute_at_location(location, query, variables, context)
         executable = executables[location]
 
         if executable.nil?
-          raise "No executable assigned for #{location} location."
+          raise StitchingError, "No executable assigned for #{location} location."
         elsif executable.is_a?(Class) && executable <= GraphQL::Schema
           executable.execute(
             query: query,
             variables: variables,
+            context: context.frozen? ? context.dup : context,
             validate: false,
           )
         elsif executable.respond_to?(:call)
-          executable.call(location, query, variables)
+          executable.call(location, query, variables, context)
         else
-          raise "Missing valid executable for #{location} location."
+          raise StitchingError, "Missing valid executable for #{location} location."
         end
       end
 
       # inverts fields map to provide fields for a type/location
+      # "Type" => "location" => ["field1", "field2", ...]
       def fields_by_type_and_location
         @fields_by_type_and_location ||= @locations_by_type_and_field.each_with_object({}) do |(type_name, fields), memo|
           memo[type_name] = fields.each_with_object({}) do |(field_name, locations), memo|
@@ -93,24 +96,55 @@ module GraphQL
         end
       end
 
+      # { "Type" => ["location1", "location2", ...] }
       def locations_by_type
         @locations_by_type ||= @locations_by_type_and_field.each_with_object({}) do |(type_name, fields), memo|
           memo[type_name] = fields.values.flatten.uniq
         end
       end
 
+      # collects all possible boundary keys for a given type
+      # { "Type" => ["id", ...] }
+      def possible_keys_for_type(type_name)
+        @possible_keys_by_type[type_name] ||= begin
+          keys = @boundaries[type_name].map { _1["selection"] }
+          keys.uniq!
+          keys
+        end
+      end
+
+      # collects possible boundary keys for a given type and location
+      # ("Type", "location") => ["id", ...]
       def possible_keys_for_type_and_location(type_name, location)
         possible_keys_by_type = @possible_keys_by_type_and_location[type_name] ||= {}
         possible_keys_by_type[location] ||= begin
           location_fields = fields_by_type_and_location[type_name][location] || []
-          location_fields & @boundaries[type_name].map { _1["selection"] }
+          location_fields & possible_keys_for_type(type_name)
         end
       end
 
-      # For a given type, route from one origin service to one or more remote locations.
-      # Tunes a-star search to favor paths with fewest joining locations, ie:
-      # favor longer paths through target locations over shorter paths with additional locations.
+      # For a given type, route from one origin location to one or more remote locations
+      # used to connect a partial type across locations via boundary queries
       def route_type_to_locations(type_name, start_location, goal_locations)
+        if possible_keys_for_type(type_name).length > 1
+          # multiple keys use an a-star search to traverse intermediary locations
+          return route_type_to_locations_via_search(type_name, start_location, goal_locations)
+        end
+
+        # types with a single key attribute must all be within a single hop of each other,
+        # so can use a simple match to collect boundaries for the goal locations.
+        @boundaries[type_name].each_with_object({}) do |boundary, memo|
+          if goal_locations.include?(boundary["location"])
+            memo[boundary["location"]] = [boundary]
+          end
+        end
+      end
+
+      private
+
+      # tunes a-star search to favor paths with fewest joining locations, ie:
+      # favor longer paths through target locations over shorter paths with additional locations.
+      def route_type_to_locations_via_search(type_name, start_location, goal_locations)
         results = {}
         costs = {}
 

data/lib/graphql/stitching/util.rb

@@ -3,13 +3,9 @@
 module GraphQL
   module Stitching
     class Util
-
-      # gets the named type at the bottom of a non-null/list wrapper tree
-      def self.get_named_type(type)
-        while type.respond_to?(:of_type)
-          type = type.of_type
-        end
-        type
+      # specifies if a type is a primitive leaf value
+      def self.is_leaf_type?(type)
+        type.kind.scalar? || type.kind.enum?
       end
 
       # strips non-null wrappers from a type
@@ -20,6 +16,31 @@ module GraphQL
         type
       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)
+        return [] unless parent_type.kind.abstract?
+        return parent_type.possible_types if parent_type.kind.union?
+
+        result = []
+        schema.types.values.each do |type|
+          next unless type <= GraphQL::Schema::Interface && type != parent_type
+          next unless type.interfaces.include?(parent_type)
+          result << type
+          result.push(*expand_abstract_type(schema, type)) if type.kind.interface?
+        end
+        result.uniq
+      end
+
       # gets a deep structural description of a list value type
       def self.get_list_structure(type)
         structure = []
@@ -38,34 +59,6 @@ module GraphQL
         end
         structure
       end
-
-      # Gets all objects and interfaces that implement a given interface
-      def self.get_possible_types(schema, parent_type)
-        return [parent_type] unless parent_type.kind.abstract?
-        return parent_type.possible_types if parent_type.kind.union?
-
-        result = []
-        schema.types.values.each do |type|
-          next unless type <= GraphQL::Schema::Interface && type != parent_type
-          next unless type.interfaces.include?(parent_type)
-          result << type
-          result.push(*get_possible_types(schema, type)) if type.kind.interface?
-        end
-        result.uniq
-      end
-
-      # Specifies if a type is a leaf node (no children)
-      def self.is_leaf_type?(type)
-        type.kind.scalar? || type.kind.enum?
-      end
-
-      def self.get_named_type_for_field_node(schema, parent_type, node)
-        if node.name == "__schema" && parent_type == schema.query
-          schema.types["__Schema"] # type mapped to phantom introspection field
-        else
-          Util.get_named_type(parent_type.fields[node.name].type)
-        end
-      end
     end
   end
 end

data/lib/graphql/stitching/version.rb

@@ -2,6 +2,6 @@
 
 module GraphQL
   module Stitching
-    VERSION = "0.1.0"
+    VERSION = "0.2.2"
   end
 end

data/lib/graphql/stitching.rb

@@ -4,6 +4,8 @@ require "graphql"
 
 module GraphQL
   module Stitching
+    EMPTY_OBJECT = {}.freeze
+
     class StitchingError < StandardError; end
 
     class << self
@@ -13,6 +15,10 @@ module GraphQL
       end
 
       attr_writer :stitch_directive
+
+      def stitching_directive_names
+        [stitch_directive]
+      end
     end
   end
 end
@@ -20,11 +26,11 @@ end
 require_relative "stitching/gateway"
 require_relative "stitching/supergraph"
 require_relative "stitching/composer"
-require_relative "stitching/document"
 require_relative "stitching/executor"
 require_relative "stitching/planner_operation"
 require_relative "stitching/planner"
 require_relative "stitching/remote_client"
+require_relative "stitching/request"
 require_relative "stitching/shaper"
 require_relative "stitching/util"
 require_relative "stitching/version"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql-stitching
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.2
 platform: ruby
 authors:
 - Greg MacWilliam
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-02-11 00:00:00.000000000 Z
+date: 2023-02-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: graphql
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.0.16
+        version: 2.0.3
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.0.16
+        version: 2.0.3
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -81,13 +81,13 @@ files:
 - Rakefile
 - docs/README.md
 - docs/composer.md
-- docs/document.md
 - docs/executor.md
 - docs/gateway.md
 - docs/images/library.png
 - docs/images/merging.png
 - docs/images/stitching.png
 - docs/planner.md
+- docs/request.md
 - docs/supergraph.md
 - example/gateway.rb
 - example/graphiql.html
@@ -99,12 +99,12 @@ files:
 - lib/graphql/stitching/composer/base_validator.rb
 - lib/graphql/stitching/composer/validate_boundaries.rb
 - lib/graphql/stitching/composer/validate_interfaces.rb
-- lib/graphql/stitching/document.rb
 - lib/graphql/stitching/executor.rb
 - lib/graphql/stitching/gateway.rb
 - lib/graphql/stitching/planner.rb
 - lib/graphql/stitching/planner_operation.rb
 - lib/graphql/stitching/remote_client.rb
+- lib/graphql/stitching/request.rb
 - lib/graphql/stitching/shaper.rb
 - lib/graphql/stitching/supergraph.rb
 - lib/graphql/stitching/util.rb

data/docs/document.md

@@ -1,15 +0,0 @@
-## GraphQL::Stitching::Document
-
-A `Document` wraps a parsed GraphQL request, and handles the logistics of extracting its appropriate operation, variable definitions, and fragments. A `Document` should be built once for a request and passed through to other stitching components that utilize document information.
-
-```ruby
-query = "query FetchMovie($id: ID!) { movie(id:$id) { id genre } }"
-document = GraphQL::Stitching::Document.new(query, operation_name: "FetchMovie")
-
-document.ast # parsed AST via GraphQL.parse
-document.string # normalized printed string
-document.digest # SHA digest of the normalized string
-
-document.variables # mapping of variable names to type definitions
-document.fragments # mapping of fragment names to fragment definitions
-```

data/lib/graphql/stitching/document.rb

@@ -1,59 +0,0 @@
-# frozen_string_literal: true
-
-module GraphQL
-  module Stitching
-    class Document
-      SUPPORTED_OPERATIONS = ["query", "mutation"].freeze
-
-      attr_reader :ast, :operation_name
-
-      def initialize(string_or_ast, operation_name: nil)
-        @ast = if string_or_ast.is_a?(String)
-          GraphQL.parse(string_or_ast)
-        else
-          string_or_ast
-        end
-
-        @operation_name = operation_name
-      end
-
-      def string
-        @string ||= GraphQL::Language::Printer.new.print(@ast)
-      end
-
-      def digest
-        @digest ||= Digest::SHA2.hexdigest(string)
-      end
-
-      def operation
-        @operation ||= begin
-          operation_defs = @ast.definitions.select do |d|
-            next unless d.is_a?(GraphQL::Language::Nodes::OperationDefinition)
-            next unless SUPPORTED_OPERATIONS.include?(d.operation_type)
-            @operation_name ? d.name == @operation_name : true
-          end
-
-          if operation_defs.length < 1
-            raise GraphQL::ExecutionError, "Invalid root operation."
-          elsif operation_defs.length > 1
-            raise GraphQL::ExecutionError, "An operation name is required when sending multiple operations."
-          end
-
-          operation_defs.first
-        end
-      end
-
-      def variable_definitions
-        @variable_definitions ||= operation.variables.each_with_object({}) do |v, memo|
-          memo[v.name] = v.type
-        end
-      end
-
-      def fragment_definitions
-        @fragment_definitions ||= @ast.definitions.each_with_object({}) do |d, memo|
-          memo[d.name] = d if d.is_a?(GraphQL::Language::Nodes::FragmentDefinition)
-        end
-      end
-    end
-  end
-end