graphql-stitching 1.0.0 → 1.0.2

data/lib/graphql/stitching/skip_include.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Stitching
+    class SkipInclude
+      class << self
+        # Faster implementation of an AST visitor for prerendering
+        # @skip and @include conditional directives into a document.
+        # This avoids unnecessary planning steps, and prepares result shaping.
+        def render(document, variables)
+          changed = false
+          definitions = document.definitions.map do |original_definition|
+            definition = render_node(original_definition, variables)
+            changed ||= definition.object_id != original_definition.object_id
+            definition
+          end
+
+          return document.merge(definitions: definitions), changed
+        end
+
+        private
+
+        def render_node(parent_node, variables)
+          changed = false
+          filtered_selections = parent_node.selections.filter_map do |original_node|
+            node = prune_node(original_node, variables)
+            if node.nil?
+              changed = true
+              next nil
+            end
+
+            node = render_node(node, variables) if node.selections.any?
+            changed ||= node.object_id != original_node.object_id
+            node
+          end
+
+          if filtered_selections.none?
+            filtered_selections << SelectionHint.typename_node
+          end
+
+          if changed
+            parent_node.merge(selections: filtered_selections)
+          else
+            parent_node
+          end
+        end
+
+        def prune_node(node, variables)
+          return node unless node.directives.any?
+
+          delete_node = false
+          filtered_directives = node.directives.reject do |directive|
+            if directive.name == "skip"
+              delete_node = assess_condition(directive.arguments.first, variables)
+              true
+            elsif directive.name == "include"
+              delete_node = !assess_condition(directive.arguments.first, variables)
+              true
+            end
+          end
+
+          if delete_node
+            nil
+          elsif filtered_directives.length != node.directives.length
+            node.merge(directives: filtered_directives)
+          else
+            node
+          end
+        end
+
+        def assess_condition(arg, variables)
+          if arg.value.is_a?(GraphQL::Language::Nodes::VariableIdentifier)
+            variables[arg.value.name] || variables[arg.value.name.to_sym]
+          else
+            arg.value
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphql/stitching/supergraph.rb

@@ -21,10 +21,14 @@ module GraphQL
           end
         end
 
+        boundaries = delegation_map["boundaries"].map do |k, b|
+          [k, b.map { Boundary.new(**_1) }]
+        end
+
         new(
           schema: schema,
           fields: delegation_map["fields"],
-          boundaries: delegation_map["boundaries"],
+          boundaries: boundaries.to_h,
           executables: executables,
         )
       end
@@ -68,7 +72,7 @@ module GraphQL
         return GraphQL::Schema::Printer.print_schema(@schema), {
           "locations" => locations,
           "fields" => fields,
-          "boundaries" => @boundaries,
+          "boundaries" => @boundaries.map { |k, b| [k, b.map(&:as_json)] }.to_h,
         }
       end
 
@@ -144,7 +148,7 @@ module GraphQL
       # ("Type") => ["id", ...]
       def possible_keys_for_type(type_name)
         @possible_keys_by_type[type_name] ||= begin
-          @boundaries[type_name].map { _1["key"] }.tap(&:uniq!)
+          @boundaries[type_name].map(&:key).tap(&:uniq!)
         end
       end
 
@@ -162,74 +166,76 @@ module GraphQL
       # 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
+          # multiple keys use an A* 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]
+          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:
+      PathNode = Struct.new(:location, :key, :cost, :boundary, keyword_init: true)
+
+      # tunes A* 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 = {}
 
         paths = possible_keys_for_type_and_location(type_name, start_location).map do |possible_key|
-          [{ location: start_location, key: possible_key, cost: 0 }]
+          [PathNode.new(location: start_location, key: possible_key, cost: 0)]
         end
 
         while paths.any?
           path = paths.pop
-          current_location = path.last[:location]
-          current_key = path.last[:key]
-          current_cost = path.last[:cost]
+          current_location = path.last.location
+          current_key = path.last.key
+          current_cost = path.last.cost
 
           @boundaries[type_name].each do |boundary|
-            forward_location = boundary["location"]
-            next if current_key != boundary["key"]
-            next if path.any? { _1[:location] == forward_location }
+            forward_location = boundary.location
+            next if current_key != boundary.key
+            next if path.any? { _1.location == forward_location }
 
             best_cost = costs[forward_location] || Float::INFINITY
             next if best_cost < current_cost
 
             path.pop
-            path << {
+            path << PathNode.new(
               location: current_location,
               key: current_key,
               cost: current_cost,
               boundary: boundary,
-            }
+            )
 
             if goal_locations.include?(forward_location)
               current_result = results[forward_location]
               if current_result.nil? || current_cost < best_cost || (current_cost == best_cost && path.length < current_result.length)
-                results[forward_location] = path.map { _1[:boundary] }
+                results[forward_location] = path.map(&:boundary)
               end
             else
-              path.last[:cost] += 1
+              path.last.cost += 1
             end
 
-            forward_cost = path.last[:cost]
+            forward_cost = path.last.cost
             costs[forward_location] = forward_cost if forward_cost < best_cost
 
             possible_keys_for_type_and_location(type_name, forward_location).each do |possible_key|
-              paths << [*path, { location: forward_location, key: possible_key, cost: forward_cost }]
+              paths << [*path, PathNode.new(location: forward_location, key: possible_key, cost: forward_cost)]
             end
           end
 
           paths.sort! do |a, b|
-            cost_diff = a.last[:cost] - b.last[:cost]
-            cost_diff.zero? ? a.length - b.length : cost_diff
-          end.reverse!
+            cost_diff = b.last.cost - a.last.cost
+            cost_diff.zero? ? b.length - a.length : cost_diff
+          end
         end
 
         results

data/lib/graphql/stitching/util.rb

@@ -3,54 +3,65 @@
 module GraphQL
   module Stitching
     class Util
-      # specifies if a type is a primitive leaf value
-      def self.is_leaf_type?(type)
-        type.kind.scalar? || type.kind.enum?
-      end
+      TypeStructure = Struct.new(:list, :null, :name, keyword_init: true) do
+        alias_method :list?, :list
+        alias_method :null?, :null
 
-      # strips non-null wrappers from a type
-      def self.unwrap_non_null(type)
-        type = type.of_type while type.non_null?
-        type
+        def non_null?
+          !null
+        end
       end
 
-      # builds a single-dimensional representation of a wrapped type structure
-      def self.flatten_type_structure(type)
-        structure = []
+      class << self
+        # specifies if a type is a primitive leaf value
+        def is_leaf_type?(type)
+          type.kind.scalar? || type.kind.enum?
+        end
+
+        # strips non-null wrappers from a type
+        def unwrap_non_null(type)
+          type = type.of_type while type.non_null?
+          type
+        end
+
+        # builds a single-dimensional representation of a wrapped type structure
+        def flatten_type_structure(type)
+          structure = []
+
+          while type.list?
+            structure << TypeStructure.new(
+              list: true,
+              null: !type.non_null?,
+              name: nil,
+            )
+
+            type = unwrap_non_null(type).of_type
+          end
 
-        while type.list?
-          structure << {
-            list: true,
+          structure << TypeStructure.new(
+            list: false,
             null: !type.non_null?,
-            name: nil,
-          }
+            name: type.unwrap.graphql_name,
+          )
 
-          type = unwrap_non_null(type).of_type
+          structure
         end
 
-        structure << {
-          list: false,
-          null: !type.non_null?,
-          name: type.unwrap.graphql_name,
-        }
-
-        structure
-      end
+        # expands interfaces and unions to an array of their memberships
+        # like `schema.possible_types`, but includes child interfaces
+        def expand_abstract_type(schema, parent_type)
+          return [] unless parent_type.kind.abstract?
+          return parent_type.possible_types if parent_type.kind.union?
 
-      # 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?
+          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.tap(&:uniq!)
         end
-        result.uniq
       end
     end
   end

data/lib/graphql/stitching/version.rb

@@ -2,6 +2,6 @@
 
 module GraphQL
   module Stitching
-    VERSION = "1.0.0"
+    VERSION = "1.0.2"
   end
 end

data/lib/graphql/stitching.rb

@@ -10,7 +10,6 @@ module GraphQL
     class StitchingError < StandardError; end
 
     class << self
-
       def stitch_directive
         @stitch_directive ||= "stitch"
       end
@@ -25,13 +24,17 @@ module GraphQL
 end
 
 require_relative "stitching/supergraph"
+require_relative "stitching/boundary"
 require_relative "stitching/client"
 require_relative "stitching/composer"
 require_relative "stitching/executor"
 require_relative "stitching/http_executable"
-require_relative "stitching/planner_operation"
+require_relative "stitching/plan"
+require_relative "stitching/planner_step"
 require_relative "stitching/planner"
 require_relative "stitching/request"
+require_relative "stitching/selection_hint"
 require_relative "stitching/shaper"
+require_relative "stitching/skip_include"
 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: 1.0.0
+  version: 1.0.2
 platform: ruby
 authors:
 - Greg MacWilliam
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-08-01 00:00:00.000000000 Z
+date: 2023-10-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: graphql
@@ -97,6 +97,7 @@ files:
 - gemfiles/graphql_1.13.9.gemfile
 - graphql-stitching.gemspec
 - lib/graphql/stitching.rb
+- lib/graphql/stitching/boundary.rb
 - lib/graphql/stitching/client.rb
 - lib/graphql/stitching/composer.rb
 - lib/graphql/stitching/composer/base_validator.rb
@@ -106,10 +107,13 @@ files:
 - lib/graphql/stitching/executor/boundary_source.rb
 - lib/graphql/stitching/executor/root_source.rb
 - lib/graphql/stitching/http_executable.rb
+- lib/graphql/stitching/plan.rb
 - lib/graphql/stitching/planner.rb
-- lib/graphql/stitching/planner_operation.rb
+- lib/graphql/stitching/planner_step.rb
 - lib/graphql/stitching/request.rb
+- lib/graphql/stitching/selection_hint.rb
 - lib/graphql/stitching/shaper.rb
+- lib/graphql/stitching/skip_include.rb
 - lib/graphql/stitching/supergraph.rb
 - lib/graphql/stitching/util.rb
 - lib/graphql/stitching/version.rb

data/lib/graphql/stitching/planner_operation.rb

@@ -1,63 +0,0 @@
-# frozen_string_literal: true
-
-module GraphQL
-  module Stitching
-    class PlannerOperation
-      LANGUAGE_PRINTER = GraphQL::Language::Printer.new
-
-      attr_reader :order, :location, :parent_type, :if_type, :operation_type, :path
-      attr_accessor :after, :selections, :variables, :boundary
-
-      def initialize(
-        location:,
-        parent_type:,
-        order:,
-        after: nil,
-        operation_type: "query",
-        selections: [],
-        variables: [],
-        path: [],
-        if_type: nil,
-        boundary: nil
-      )
-        @location = location
-        @parent_type = parent_type
-        @order = order
-        @after = after
-        @operation_type = operation_type
-        @selections = selections
-        @variables = variables
-        @path = path
-        @if_type = if_type
-        @boundary = boundary
-      end
-
-      def selection_set
-        op = GraphQL::Language::Nodes::OperationDefinition.new(selections: @selections)
-        LANGUAGE_PRINTER.print(op).gsub!(/\s+/, " ").strip!
-      end
-
-      def variable_set
-        @variables.each_with_object({}) do |(variable_name, value_type), memo|
-          memo[variable_name] = LANGUAGE_PRINTER.print(value_type)
-        end
-      end
-
-      def to_h
-        data = {
-          "order" => @order,
-          "after" => @after,
-          "location" => @location,
-          "operation_type" => @operation_type,
-          "selections" => selection_set,
-          "variables" => variable_set,
-          "path" => @path,
-        }
-
-        data["if_type"] = @if_type if @if_type
-        data["boundary"] = @boundary if @boundary
-        data
-      end
-    end
-  end
-end