graphql-stitching 1.0.0 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9ff6bbdb8e949da02a0ed58f6db5ab56a6e622d9befc436042dcaaed6556a0f0
-  data.tar.gz: ecb682677bb576a3742e1a0ebf8eabe4d17e2dfbc214120aed4cbef09db881df
+  metadata.gz: 4ce8bb1075d536f01aa63487df3e1686bc0c2899b58ca14e95383caef38812e2
+  data.tar.gz: ae39e685bdb31cbf3962216cfce263b2970aa2aeac6be1901a7397cee6eb1656
 SHA512:
-  metadata.gz: 506a02bced23940043c43bfb59b4a3cba9cf98c7177f0f0abe58b16b0543498cb7acdeecac4d44d22d867d3dd12f3be756236b36ac534e22eb3ed2f347f16984
-  data.tar.gz: b409cbe17f3d4792bb8aa4ae0553d8d15dcb5a5316999248a66644fabae67133036804f9a34d805b3bed58e11e40158ca36444365f80773e945c2b586588fd39
+  metadata.gz: e718527102969773accf28b2323cbde1d2c467339c44bb876144ae5387a7aaec64143b35b6dfff21401fb087c64ed8742f79cda78e743518ba045871c320f51f
+  data.tar.gz: 74bc97f475b61ea51dd8ce9e42a1ff2783d0c1717a38ff812e256962d64b97ef0ccc092de11e529a22e274d8ad5cf77af9fd7ed2fd680e20e0c058534942a5d6

data/README.md

@@ -9,7 +9,7 @@ GraphQL stitching composes a single schema from multiple underlying GraphQL reso
 - Multiple keys per merged type.
 - Shared objects, fields, enums, and inputs across locations.
 - Combining local and remote schemas.
-- Type merging via federation `_entities` protocol.
+- Type merging via arbitrary queries or federation `_entities` protocol.
 
 **NOT Supported:**
 - Computed fields (ie: federation-style `@requires`).

data/lib/graphql/stitching/boundary.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Stitching
+    Boundary = Struct.new(
+      :location,
+      :type_name,
+      :key,
+      :field,
+      :arg,
+      :list,
+      :federation,
+      keyword_init: true
+    ) do
+      def as_json
+        {
+          location: location,
+          type_name: type_name,
+          key: key,
+          field: field,
+          arg: arg,
+          list: list,
+          federation: federation,
+        }.tap(&:compact!)
+      end
+    end
+  end
+end

data/lib/graphql/stitching/client.rb

@@ -41,7 +41,7 @@ module GraphQL
           GraphQL::Stitching::Planner.new(
             supergraph: @supergraph,
             request: request,
-          ).perform.to_h
+          ).perform
         end
 
         GraphQL::Stitching::Executor.new(
@@ -76,16 +76,16 @@ module GraphQL
       def fetch_plan(request)
         if @on_cache_read
           cached_plan = @on_cache_read.call(request.digest, request.context)
-          return JSON.parse(cached_plan) if cached_plan
+          return GraphQL::Stitching::Plan.from_json(JSON.parse(cached_plan)) if cached_plan
         end
 
-        plan_json = yield
+        plan = yield
 
         if @on_cache_write
-          @on_cache_write.call(request.digest, JSON.generate(plan_json), request.context)
+          @on_cache_write.call(request.digest, JSON.generate(plan.as_json), request.context)
         end
 
-        plan_json
+        plan
       end
 
       def error_result(errors)

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

@@ -32,16 +32,16 @@ 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["key"])
-            raise Composer::ValidationError, "Multiple boundary queries for `#{type.graphql_name}.#{boundary["key"]}` "\
-              "found in #{boundary["location"]}. Limit one boundary query per type and key in each location. "\
+          if memo.dig(boundary.location, boundary.key)
+            raise Composer::ValidationError, "Multiple boundary queries for `#{type.graphql_name}.#{boundary.key}` "\
+              "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["key"]] = boundary
+          memo[boundary.location] ||= {}
+          memo[boundary.location][boundary.key] = boundary
         end
 
-        boundary_keys = boundaries.map { _1["key"] }.uniq
+        boundary_keys = boundaries.map { _1.key }.uniq
         key_only_types_by_location = candidate_types_by_location.select do |location, subschema_type|
           subschema_type.fields.keys.length == 1 && boundary_keys.include?(subschema_type.fields.keys.first)
         end

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

@@ -32,12 +32,12 @@ module GraphQL
               interface_type_structure.each_with_index do |interface_struct, index|
                 possible_struct = possible_type_structure[index]
 
-                if possible_struct[:name] != interface_struct[:name]
+                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]
+                if possible_struct.null? && interface_struct.non_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

data/lib/graphql/stitching/composer.rb

@@ -430,21 +430,21 @@ module GraphQL
             raise ComposerError, "Cannot compose mixed list structures at `#{path}`."
           end
 
-          if alt_structure.last[:name] != basis_structure.last[:name]
+          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.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] }
+          non_null = alt_structures.each_with_object([basis.non_null?]) { |s, m| m << s[rev_index].non_null? }
 
-          type = type.to_list_type if basis[:list]
+          type = type.to_list_type if basis.list?
           type = type.to_non_null_type if argument_name ? non_null.any? : non_null.all?
         end
 
@@ -509,15 +509,15 @@ module GraphQL
               end
 
               @boundary_map[impl_type_name] ||= []
-              @boundary_map[impl_type_name] << {
-                "location" => location,
-                "type_name" => impl_type_name,
-                "key" => key_selections[0].name,
-                "field" => field_candidate.name,
-                "arg" => argument_name,
-                "list" => boundary_structure.first[:list],
-                "federation" => kwargs[:federation],
-              }.compact
+              @boundary_map[impl_type_name] << Boundary.new(
+                location: location,
+                type_name: impl_type_name,
+                key: key_selections[0].name,
+                field: field_candidate.name,
+                arg: argument_name,
+                list: boundary_structure.first.list?,
+                federation: kwargs[:federation],
+              )
             end
           end
         end

data/lib/graphql/stitching/executor/boundary_source.rb

@@ -10,13 +10,13 @@ module GraphQL
 
       def fetch(ops)
         origin_sets_by_operation = ops.each_with_object({}) do |op, memo|
-          origin_set = op["path"].reduce([@executor.data]) do |set, path_segment|
+          origin_set = op.path.reduce([@executor.data]) do |set, path_segment|
             set.flat_map { |obj| obj && obj[path_segment] }.tap(&:compact!)
           end
 
-          if op["if_type"]
+          if op.if_type
             # operations planned around unused fragment conditions should not trigger requests
-            origin_set.select! { _1["_STITCH_typename"] == op["if_type"] }
+            origin_set.select! { _1[SelectionHint.typename_node.alias] == op.if_type }
           end
 
           memo[op] = origin_set if origin_set.any?
@@ -34,7 +34,7 @@ module GraphQL
           @executor.errors.concat(extract_errors!(origin_sets_by_operation, errors)) if errors&.any?
         end
 
-        ops.map { origin_sets_by_operation[_1] ? _1["order"] : nil }
+        ops.map { origin_sets_by_operation[_1] ? _1.step : nil }
       end
 
       # Builds batched boundary queries
@@ -47,21 +47,21 @@ module GraphQL
       def build_document(origin_sets_by_operation, operation_name = nil)
         variable_defs = {}
         query_fields = origin_sets_by_operation.map.with_index do |(op, origin_set), batch_index|
-          variable_defs.merge!(op["variables"])
-          boundary = op["boundary"]
+          variable_defs.merge!(op.variables)
+          boundary = op.boundary
 
-          if boundary["list"]
+          if boundary.list
             input = origin_set.each_with_index.reduce(String.new) do |memo, (origin_obj, index)|
               memo << "," if index > 0
-              memo << build_key(boundary["key"], origin_obj, federation: boundary["federation"])
+              memo << build_key(boundary.key, origin_obj, federation: boundary.federation)
               memo
             end
 
-            "_#{batch_index}_result: #{boundary["field"]}(#{boundary["arg"]}:[#{input}]) #{op["selections"]}"
+            "_#{batch_index}_result: #{boundary.field}(#{boundary.arg}:[#{input}]) #{op.selections}"
           else
             origin_set.map.with_index do |origin_obj, index|
-              input = build_key(boundary["key"], origin_obj, federation: boundary["federation"])
-              "_#{batch_index}_#{index}_result: #{boundary["field"]}(#{boundary["arg"]}:#{input}) #{op["selections"]}"
+              input = build_key(boundary.key, origin_obj, federation: boundary.federation)
+              "_#{batch_index}_#{index}_result: #{boundary.field}(#{boundary.arg}:#{input}) #{op.selections}"
             end
           end
         end
@@ -71,7 +71,7 @@ module GraphQL
         if operation_name
           doc << " #{operation_name}"
           origin_sets_by_operation.each_key do |op|
-            doc << "_#{op["order"]}"
+            doc << "_#{op.step}"
           end
         end
 
@@ -86,9 +86,9 @@ module GraphQL
       end
 
       def build_key(key, origin_obj, federation: false)
-        key_value = JSON.generate(origin_obj["_STITCH_#{key}"])
+        key_value = JSON.generate(origin_obj[SelectionHint.key(key)])
         if federation
-          "{ __typename: \"#{origin_obj["_STITCH_typename"]}\", #{key}: #{key_value} }"
+          "{ __typename: \"#{origin_obj[SelectionHint.typename_node.alias]}\", #{key}: #{key_value} }"
         else
           key_value
         end

data/lib/graphql/stitching/executor/root_source.rb

@@ -12,8 +12,8 @@ module GraphQL
         op = ops.first # There should only ever be one per location at a time
 
         query_document = build_document(op, @executor.request.operation_name)
-        query_variables = @executor.request.variables.slice(*op["variables"].keys)
-        result = @executor.supergraph.execute_at_location(op["location"], query_document, query_variables, @executor.request.context)
+        query_variables = @executor.request.variables.slice(*op.variables.keys)
+        result = @executor.supergraph.execute_at_location(op.location, query_document, query_variables, @executor.request.context)
         @executor.query_count += 1
 
         @executor.data.merge!(result["data"]) if result["data"]
@@ -22,25 +22,25 @@ module GraphQL
           @executor.errors.concat(result["errors"])
         end
 
-        ops.map { op["order"] }
+        ops.map(&:step)
       end
 
       # Builds root source documents
       # "query MyOperation_1($var:VarType) { rootSelections ... }"
       def build_document(op, operation_name = nil)
         doc = String.new
-        doc << op["operation_type"]
+        doc << op.operation_type
 
         if operation_name
-          doc << " #{operation_name}_#{op["order"]}"
+          doc << " #{operation_name}_#{op.step}"
         end
 
-        if op["variables"].any?
-          variable_defs = op["variables"].map { |k, v| "$#{k}:#{v}" }.join(",")
+        if op.variables.any?
+          variable_defs = op.variables.map { |k, v| "$#{k}:#{v}" }.join(",")
           doc << "(#{variable_defs})"
         end
 
-        doc << op["selections"]
+        doc << op.selections
         doc
       end
     end

data/lib/graphql/stitching/executor.rb

@@ -11,7 +11,7 @@ module GraphQL
       def initialize(supergraph:, request:, plan:, nonblocking: false)
         @supergraph = supergraph
         @request = request
-        @queue = plan["ops"]
+        @queue = plan.ops
         @data = {}
         @errors = []
         @query_count = 0
@@ -47,8 +47,8 @@ module GraphQL
 
         @dataloader.append_job do
           tasks = @queue
-            .select { next_ordinals.include?(_1["after"]) }
-            .group_by { [_1["location"], _1["boundary"].nil?] }
+            .select { next_ordinals.include?(_1.after) }
+            .group_by { [_1.location, _1.boundary.nil?] }
             .map do |(location, root_source), ops|
               if root_source
                 @dataloader.with(RootSource, self, location).request_all(ops)

data/lib/graphql/stitching/plan.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Stitching
+    class Plan
+      Op = Struct.new(
+        :step,
+        :after,
+        :location,
+        :operation_type,
+        :selections,
+        :variables,
+        :path,
+        :if_type,
+        :boundary,
+        keyword_init: true
+      ) do
+        def as_json
+          {
+            step: step,
+            after: after,
+            location: location,
+            operation_type: operation_type,
+            selections: selections,
+            variables: variables,
+            path: path,
+            if_type: if_type,
+            boundary: boundary&.as_json
+          }.tap(&:compact!)
+        end
+      end
+
+      class << self
+        def from_json(json)
+          ops = json["ops"]
+          ops = ops.map do |op|
+            boundary = op["boundary"]
+            Op.new(
+              step: op["step"],
+              after: op["after"],
+              location: op["location"],
+              operation_type: op["operation_type"],
+              selections: op["selections"],
+              variables: op["variables"],
+              path: op["path"],
+              if_type: op["if_type"],
+              boundary: boundary ? GraphQL::Stitching::Boundary.new(**boundary) : nil,
+            )
+          end
+          new(ops: ops)
+        end
+      end
+
+      attr_reader :ops
+
+      def initialize(ops: [])
+        @ops = ops
+      end
+
+      def as_json
+        { ops: @ops.map(&:as_json) }
+      end
+    end
+  end
+end