graphql-stitching 0.0.1

data/lib/graphql/stitching/planner_operation.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Stitching
+    class PlannerOperation
+      attr_reader :key, :location, :parent_type, :type_condition, :operation_type, :insertion_path
+      attr_accessor :after_key, :selections, :variables, :boundary
+
+      def initialize(
+        key:,
+        location:,
+        parent_type:,
+        operation_type: "query",
+        insertion_path: [],
+        type_condition: nil,
+        after_key: nil,
+        selections: [],
+        variables: [],
+        boundary: nil
+      )
+        @key = key
+        @after_key = after_key
+        @location = location
+        @parent_type = parent_type
+        @operation_type = operation_type
+        @insertion_path = insertion_path
+        @type_condition = type_condition
+        @selections = selections
+        @variables = variables
+        @boundary = boundary
+      end
+
+      def selection_set
+        op = GraphQL::Language::Nodes::OperationDefinition.new(selections: @selections)
+        GraphQL::Language::Printer.new.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)
+        end
+      end
+
+      def to_h
+        {
+          "key" => @key,
+          "after_key" => @after_key,
+          "location" => @location,
+          "operation_type" => @operation_type,
+          "insertion_path" => @insertion_path,
+          "type_condition" => @type_condition,
+          "selections" => selection_set,
+          "variables" => variable_set,
+          "boundary" => @boundary,
+        }
+      end
+    end
+  end
+end

data/lib/graphql/stitching/remote_client.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "uri"
+require "json"
+
+module GraphQL
+  module Stitching
+    class RemoteClient
+      def initialize(url:, headers:{})
+        @url = url
+        @headers = headers
+      end
+
+      def call(location, document, variables)
+        response = Net::HTTP.post(
+          URI(@url),
+          { "query" => document, "variables" => variables }.to_json,
+          { "Content-Type" => "application/json" }.merge!(@headers)
+        )
+        JSON.parse(response.body)
+      end
+    end
+  end
+end

data/lib/graphql/stitching/shaper.rb

@@ -0,0 +1,92 @@
+# typed: false
+# frozen_string_literal: true
+
+module GraphQL
+  module Stitching
+    class Shaper
+      def initialize(supergraph:, document:, raw:)
+        @supergraph = supergraph
+        @document = document
+        @result = raw
+        @errors = []
+      end
+
+      def perform!
+        if @result.key?("data") && ! @result["data"].empty?
+          munge_entry(@result["data"], @document.operation.selections, @supergraph.schema.query)
+          # hate doing a second pass, but cannot remove _STITCH_ fields until the fragements are processed
+          clean_entry(@result["data"])
+        end
+
+        if @errors.length > 0
+          @result = [] unless @result.key?("errors")
+          @result["errors"] += @errors
+        end
+
+        @result
+      end
+
+      private
+
+      def munge_entry(entry, selections, parent_type)
+        selections.each do |node|
+          case node
+          when GraphQL::Language::Nodes::Field
+            next if node.respond_to?(:name) && node&.name == "__typename"
+
+            munge_field(entry, node, parent_type)
+
+          when GraphQL::Language::Nodes::InlineFragment
+            next unless entry["_STITCH_typename"] == node.type.name
+            fragment_type = @supergraph.schema.types[node.type.name]
+            munge_entry(entry, node.selections, fragment_type)
+
+          when GraphQL::Language::Nodes::FragmentSpread
+            next unless entry["_STITCH_typename"] == node.name
+            fragment = @document.fragment_definitions[node.name]
+            fragment_type = @supergraph.schema.types[node.name]
+            munge_entry(entry, fragment.selections, fragment_type)
+          else
+            raise "Unexpected node of type #{node.class.name} in selection set."
+          end
+        end
+      end
+
+      def munge_field(entry, node, parent_type)
+        field_identifier = (node.alias || node.name)
+        node_type = Util.get_named_type_for_field_node(@supergraph.schema, parent_type, node)
+
+        if entry.nil?
+          return  # TODO bubble up error if not nullable
+        end
+
+        child_entry = entry[field_identifier]
+        if child_entry.nil?
+          entry[field_identifier] = nil
+        elsif child_entry.is_a? Array
+          child_entry.each do |raw_item|
+            munge_entry(raw_item, node.selections, node_type)
+          end
+        elsif ! Util.is_leaf_type?(node_type)
+          munge_entry(child_entry, node.selections, node_type)
+        end
+      end
+
+      def clean_entry(entry)
+        return if entry.nil?
+
+        entry.each do |key, value|
+          if key.start_with? "_STITCH_"
+            entry.delete(key)
+          elsif value.is_a?(Array)
+            value.each do |item|
+              clean_entry(item)
+            end
+          elsif value.is_a?(Hash)
+            clean_entry(value)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphql/stitching/supergraph.rb

@@ -0,0 +1,171 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Stitching
+    class Supergraph
+      LOCATION = "__super"
+      INTROSPECTION_TYPES = [
+        "__Schema",
+        "__Type",
+        "__Field",
+        "__Directive",
+        "__EnumValue",
+        "__InputValue",
+        "__TypeKind",
+        "__DirectiveLocation",
+      ].freeze
+
+      attr_reader :schema, :boundaries, :locations_by_type_and_field, :executables
+
+      def initialize(schema:, fields:, boundaries:, executables: {})
+        @schema = schema
+        @boundaries = boundaries
+        @locations_by_type_and_field = INTROSPECTION_TYPES.each_with_object(fields) do |type_name, memo|
+          introspection_type = schema.get_type(type_name)
+          next unless introspection_type.kind.fields?
+
+          memo[type_name] = introspection_type.fields.keys.each_with_object({}) do |field_name, m|
+            m[field_name] = [LOCATION]
+          end
+        end
+
+        @possible_keys_by_type_and_location = {}
+        @executables = { LOCATION => @schema }.merge!(executables)
+      end
+
+      def fields
+        @locations_by_type_and_field.reject { |k, _v| INTROSPECTION_TYPES.include?(k) }
+      end
+
+      def export
+        return GraphQL::Schema::Printer.print_schema(@schema), {
+          "fields" => fields,
+          "boundaries" => @boundaries,
+        }
+      end
+
+      def self.from_export(schema, delegation_map, executables: {})
+        schema = GraphQL::Schema.from_definition(schema) if schema.is_a?(String)
+        new(
+          schema: schema,
+          fields: delegation_map["fields"],
+          boundaries: delegation_map["boundaries"],
+          executables: executables,
+        )
+      end
+
+      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)
+        end
+        @executables[location] = executable
+      end
+
+      def execute_at_location(location, query, variables)
+        executable = executables[location]
+
+        if executable.nil?
+          raise "No executable assigned for #{location} location."
+        elsif executable.is_a?(Class) && executable <= GraphQL::Schema
+          executable.execute(
+            query: query,
+            variables: variables,
+            validate: false,
+          )
+        elsif executable.respond_to?(:call)
+          executable.call(location, query, variables)
+        else
+          raise "Missing valid executable for #{location} location."
+        end
+      end
+
+      # inverts fields map to provide fields for a type/location
+      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|
+            locations.each do |location|
+              memo[location] ||= []
+              memo[location] << field_name
+            end
+          end
+        end
+      end
+
+      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
+
+      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"] }
+        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.
+      def route_type_to_locations(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, selection: possible_key, cost: 0 }]
+        end
+
+        while paths.any?
+          path = paths.pop
+          current_location = path.last[:location]
+          current_selection = path.last[:selection]
+          current_cost = path.last[:cost]
+
+          @boundaries[type_name].each do |boundary|
+            forward_location = boundary["location"]
+            next if current_selection != boundary["selection"]
+            next if path.any? { _1[:location] == forward_location }
+
+            best_cost = costs[forward_location] || Float::INFINITY
+            next if best_cost < current_cost
+
+            path.pop
+            path << {
+              location: current_location,
+              selection: current_selection,
+              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] }
+              end
+            else
+              path.last[:cost] += 1
+            end
+
+            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, selection: possible_key, cost: forward_cost }]
+            end
+          end
+
+          paths.sort! do |a, b|
+            cost_diff = a.last[:cost] - b.last[:cost]
+            next cost_diff unless cost_diff.zero?
+            a.length - b.length
+          end.reverse!
+        end
+
+        results
+      end
+    end
+  end
+end

data/lib/graphql/stitching/util.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Stitching
+    class Util
+
+      # gets the named type at the bottom of a non-null/list wrapper chain
+      def self.get_named_type(type)
+        while type.respond_to?(:of_type)
+          type = type.of_type
+        end
+        type
+      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
+
+      # 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

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Stitching
+    VERSION = "0.0.1"
+  end
+end

data/lib/graphql/stitching.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "graphql"
+
+module GraphQL
+  module Stitching
+    class StitchingError < StandardError; end
+
+    class << self
+
+      def stitch_directive
+        @stitch_directive ||= "stitch"
+      end
+
+      attr_writer :stitch_directive
+    end
+  end
+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/shaper"
+require_relative "stitching/util"
+require_relative "stitching/version"

metadata

@@ -0,0 +1,142 @@
+--- !ruby/object:Gem::Specification
+name: graphql-stitching
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Greg MacWilliam
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2023-02-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: graphql
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.0.16
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.0.16
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.12'
+description: GraphQL schema stitching for Ruby
+email:
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".github/workflows/ci.yml"
+- ".gitignore"
+- ".ruby-version"
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- Procfile
+- README.md
+- 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/shaper.md
+- docs/supergraph.md
+- example/gateway.rb
+- example/graphiql.html
+- example/remote1.rb
+- example/remote2.rb
+- graphql-stitching.gemspec
+- lib/graphql/stitching.rb
+- lib/graphql/stitching/composer.rb
+- 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/shaper.rb
+- lib/graphql/stitching/supergraph.rb
+- lib/graphql/stitching/util.rb
+- lib/graphql/stitching/version.rb
+homepage: https://github.com/gmac/graphql-stitching-ruby
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/gmac/graphql-stitching-ruby
+  changelog_uri: https://github.com/gmac/graphql-stitching-ruby/releases
+  source_code_uri: https://github.com/gmac/graphql-stitching-ruby
+  bug_tracker_uri: https://github.com/gmac/graphql-stitching-ruby/issues
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.1.1
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.7
+signing_key:
+specification_version: 4
+summary: GraphQL schema stitching for Ruby
+test_files: []