graphql-stitching 1.3.0 → 1.4.1

data/lib/graphql/stitching/resolver/arguments.rb

@@ -0,0 +1,284 @@
+# frozen_string_literal: true
+
+module GraphQL::Stitching
+  class Resolver
+    # Defines a single resolver argument structure
+    # @api private
+    class Argument
+      attr_reader :name
+      attr_reader :value
+      attr_reader :type_name
+
+      def initialize(name:, value:, list: false, type_name: nil)
+        @name = name
+        @value = value
+        @list = list
+        @type_name = type_name
+      end
+
+      def list?
+        @list
+      end
+
+      def key?
+        value.key?
+      end
+
+      def verify_key(key)
+        if key?
+          value.verify_key(self, key)
+          true
+        else
+          false
+        end
+      end
+
+      def ==(other)
+        self.class == other.class &&
+          @name == other.name &&
+          @value == other.value &&
+          @type_name == other.type_name &&
+          @list == other.list?
+      end
+
+      def build(origin_obj)
+        value.build(origin_obj)
+      end
+
+      def print
+        "#{name}: #{value.print}"
+      end
+
+      def to_definition
+        print.gsub(%|"|, "'")
+      end
+
+      alias_method :to_s, :to_definition
+
+      def to_type_definition
+        "#{name}: #{to_type_signature}"
+      end
+
+      def to_type_signature
+        # need to derive nullability...
+        list? ? "[#{@type_name}!]!" : "#{@type_name}!"
+      end
+    end
+
+    # An abstract argument input value
+    # @api private
+    class ArgumentValue
+      attr_reader :value
+
+      def initialize(value)
+        @value = value
+      end
+
+      def key?
+        false
+      end
+
+      def verify_key(arg, key)
+        nil
+      end
+
+      def ==(other)
+        self.class == other.class && value == other.value
+      end
+
+      def build(origin_obj)
+        value
+      end
+
+      def print
+        value
+      end
+    end
+
+    # An object input value
+    # @api private
+    class ObjectArgumentValue < ArgumentValue
+      def key?
+        value.any?(&:key?)
+      end
+
+      def verify_key(arg, key)
+        value.each { _1.verify_key(key) }
+      end
+
+      def build(origin_obj)
+        value.each_with_object({}) do |arg, memo|
+          memo[arg.name] = arg.build(origin_obj)
+        end
+      end
+
+      def print
+        "{#{value.map(&:print).join(", ")}}"
+      end
+    end
+
+    # A key input value
+    # @api private
+    class KeyArgumentValue < ArgumentValue
+      def initialize(value)
+        super(Array(value))
+      end
+
+      def key?
+        true
+      end
+
+      def verify_key(arg, key)
+        key_field = value.reduce(Resolver::KeyField.new("", inner: key)) do |field, ns|
+          if ns == Resolver::TYPE_NAME
+            Resolver::KeyField.new(Resolver::TYPE_NAME)
+          elsif field
+            field.inner.find { _1.name == ns }
+          end
+        end
+
+        # still not capturing enough type information to accurately compare key/arg types...
+        # best we can do for now is to verify the argument insertion matches a key path.
+        if key_field.nil?
+          raise CompositionError, "Argument `#{arg.name}: #{print}` cannot insert key `#{key.to_definition}`."
+        end
+      end
+
+      def build(origin_obj)
+        value.each_with_index.reduce(origin_obj) do |obj, (ns, idx)|
+          obj[idx.zero? ? Resolver.export_key(ns) : ns]
+        end
+      end
+
+      def print
+        "$.#{value.join(".")}"
+      end
+    end
+
+    # A typed enum input value
+    # @api private
+    class EnumArgumentValue < ArgumentValue
+    end
+
+    # A primitive input value literal
+    # @api private
+    class LiteralArgumentValue < ArgumentValue
+      def print
+        JSON.generate(value)
+      end
+    end
+
+    # Parser for building argument templates into resolver structures
+    # @api private
+    module ArgumentsParser
+      # Parses an argument template string into resolver arguments via schema casting.
+      # @param template [String] the template string to parse.
+      # @param field_def [GraphQL::Schema::FieldDefinition] a field definition providing arguments schema.
+      # @return [[GraphQL::Stitching::Resolver::Argument]] an array of resolver arguments.
+      def parse_arguments_with_field(template, field_def)
+        ast = parse_arg_defs(template)
+        args = build_argument_set(ast, field_def.arguments)
+        args.each do |arg|
+          next unless arg.key?
+
+          if field_def.type.list? && !arg.list?
+            raise CompositionError, "Cannot use repeatable key for `#{field_def.owner.graphql_name}.#{field_def.graphql_name}` " \
+              "in non-list argument `#{arg.name}`."
+          elsif !field_def.type.list? && arg.list?
+            raise CompositionError, "Cannot use non-repeatable key for `#{field_def.owner.graphql_name}.#{field_def.graphql_name}` " \
+              "in list argument `#{arg.name}`."
+          end
+        end
+
+        args
+      end
+
+      # Parses an argument template string into resolver arguments via SDL casting.
+      # @param template [String] the template string to parse.
+      # @param type_defs [String] the type definition string declaring argument types.
+      # @return [[GraphQL::Stitching::Resolver::Argument]] an array of resolver arguments.
+      def parse_arguments_with_type_defs(template, type_defs)
+        type_map = parse_type_defs(type_defs)
+        parse_arg_defs(template).map { build_argument(_1, type_struct: type_map[_1.name]) }
+      end
+
+      private
+
+      def parse_arg_defs(template)
+        template = template
+          .gsub("'", %|"|) # 'sfoo' -> "sfoo"
+          .gsub(/(\$[\w\.]+)/) { %|"#{_1}"| } # $.key -> "$.key"
+          .tap(&:strip!)
+
+        template = template[1..-2] if template.start_with?("(") && template.end_with?(")")
+
+        GraphQL.parse("{ f(#{template}) }")
+          .definitions.first
+          .selections.first
+          .arguments
+      end
+
+      def parse_type_defs(template)
+        GraphQL.parse("type T { #{template} }")
+          .definitions.first
+          .fields.each_with_object({}) do |node, memo|
+            memo[node.name] = GraphQL::Stitching::Util.flatten_ast_type_structure(node.type)
+          end
+      end
+
+      def build_argument_set(nodes, argument_defs)
+        if argument_defs
+          argument_defs.each_value do |argument_def|
+            if argument_def.type.non_null? && !nodes.find { _1.name == argument_def.graphql_name }
+              raise CompositionError, "Required argument `#{argument_def.graphql_name}` has no input."
+            end
+          end
+        end
+
+        nodes.map do |node|
+          argument_def = if argument_defs
+            arg = argument_defs[node.name]
+            raise CompositionError, "Input `#{node.name}` is not a valid argument." unless arg
+            arg
+          end
+
+          build_argument(node, argument_def: argument_def)
+        end
+      end
+
+      def build_argument(node, argument_def: nil, type_struct: nil)
+        value = if node.value.is_a?(GraphQL::Language::Nodes::InputObject)
+          build_object_value(node.value, argument_def ? argument_def.type.unwrap : nil)
+        elsif node.value.is_a?(GraphQL::Language::Nodes::Enum)
+          EnumArgumentValue.new(node.value.name)
+        elsif node.value.is_a?(String) && node.value.start_with?("$.")
+          KeyArgumentValue.new(node.value.sub(/^\$\./, "").split("."))
+        else
+          LiteralArgumentValue.new(node.value)
+        end
+
+        Argument.new(
+          name: node.name,
+          value: value,
+          # doesn't support nested lists...?
+          list: argument_def ? argument_def.type.list? : (type_struct&.first&.list? || false),
+          type_name: argument_def ? argument_def.type.unwrap.graphql_name : type_struct&.last&.name,
+        )
+      end
+
+      def build_object_value(node, object_def)
+        if object_def
+          if !object_def.kind.input_object? && !object_def.kind.scalar?
+            raise CompositionError, "Objects can only be built into input object and scalar positions."
+          elsif object_def.kind.scalar? && GraphQL::Schema::BUILT_IN_TYPES[object_def.graphql_name]
+            raise CompositionError, "Objects can only be built into custom scalar types."
+          elsif object_def.kind.scalar?
+            object_def = nil
+          end
+        end
+
+        ObjectArgumentValue.new(build_argument_set(node.arguments, object_def&.arguments))
+      end
+    end
+  end
+end

data/lib/graphql/stitching/resolver/keys.rb

@@ -0,0 +1,206 @@
+# frozen_string_literal: true
+
+module GraphQL::Stitching
+  class Resolver
+    EXPORT_PREFIX = "_export_"
+    TYPE_NAME = "__typename"
+
+    class FieldNode
+      # GraphQL Ruby changed the argument assigning Field.alias from
+      # a generic `alias` hash key to a structured `field_alias` kwarg
+      # in https://github.com/rmosolgo/graphql-ruby/pull/4718.
+      # This adapts to the library implementation present.
+      GRAPHQL_RUBY_FIELD_ALIAS_KWARG = !GraphQL::Language::Nodes::Field.new(field_alias: "a").alias.nil?
+
+      class << self
+        def build(field_name:, field_alias: nil, selections: GraphQL::Stitching::EMPTY_ARRAY)
+          if GRAPHQL_RUBY_FIELD_ALIAS_KWARG
+            GraphQL::Language::Nodes::Field.new(
+              field_alias: field_alias,
+              name: field_name,
+              selections: selections,
+            )
+          else
+            GraphQL::Language::Nodes::Field.new(
+              alias: field_alias,
+              name: field_name,
+              selections: selections,
+            )
+          end
+        end
+      end
+    end
+
+    class KeyFieldSet < Array
+      def initialize(fields)
+        super(fields.sort_by(&:name))
+        @to_definition = nil
+        @export_nodes = nil
+      end
+
+      def ==(other)
+        to_definition == other.to_definition
+      end
+
+      def default_argument_name
+        length == 1 ? first.name : nil
+      end
+
+      def to_definition
+        @to_definition ||= map(&:to_definition).join(" ").freeze
+      end
+
+      alias_method :to_s, :to_definition
+
+      def export_nodes
+        @export_nodes ||= map(&:export_node)
+      end
+    end
+
+    EMPTY_FIELD_SET = KeyFieldSet.new(GraphQL::Stitching::EMPTY_ARRAY)
+    TYPENAME_EXPORT_NODE = FieldNode.build(
+      field_alias: "#{EXPORT_PREFIX}#{TYPE_NAME}",
+      field_name: TYPE_NAME,
+    )
+
+    class Key < KeyFieldSet
+      attr_reader :locations
+
+      def initialize(fields, locations: GraphQL::Stitching::EMPTY_ARRAY)
+        super(fields)
+        @locations = locations
+        to_definition
+        export_nodes
+        freeze
+      end
+
+      def export_nodes
+        @export_nodes ||= begin
+          nodes = map(&:export_node)
+          nodes << TYPENAME_EXPORT_NODE
+          nodes
+        end
+      end
+    end
+
+    class KeyField
+      # name of the key, may be a field alias
+      attr_reader :name
+
+      # inner key selections
+      attr_reader :inner
+
+      # optional information about location and typing, used during composition
+      attr_accessor :type_name
+      attr_accessor :list
+      alias_method :list?, :list
+
+      def initialize(name, root: false, inner: EMPTY_FIELD_SET)
+        @name = name
+        @inner = inner
+        @root = root
+      end
+
+      def to_definition
+        @inner.empty? ? @name : "#{@name} { #{@inner.to_definition} }"
+      end
+
+      def export_node
+        FieldNode.build(
+          field_alias: @root ? "#{EXPORT_PREFIX}#{@name}" : nil,
+          field_name: @name,
+          selections: @inner.export_nodes,
+        )
+      end
+    end
+
+    module KeysParser
+      def export_key(name)
+        "#{EXPORT_PREFIX}#{name}"
+      end
+
+      def export_key?(name)
+        return false unless name
+
+        name.start_with?(EXPORT_PREFIX)
+      end
+
+      def parse_key(template, locations = GraphQL::Stitching::EMPTY_ARRAY)
+        Key.new(parse_field_set(template), locations: locations)
+      end
+
+      def parse_key_with_types(template, subgraph_types_by_location)
+        field_set = parse_field_set(template)
+        locations = subgraph_types_by_location.filter_map do |location, subgraph_type|
+          location if field_set_matches_type?(field_set, subgraph_type)
+        end
+
+        if locations.none?
+          message = "Key `#{field_set.to_definition}` does not exist in any location."
+          message += " Composite key selections may not be distributed." if field_set.length > 1
+          raise CompositionError, message
+        end
+
+        assign_field_set_info!(field_set, subgraph_types_by_location[locations.first])
+        Key.new(field_set, locations: locations)
+      end
+
+      private
+
+      def parse_field_set(template)
+        template = template.strip
+        template = template[1..-2] if template.start_with?("{") && template.end_with?("}")
+
+        ast = GraphQL.parse("{ #{template} }").definitions.first.selections
+        build_field_set(ast, root: true)
+      end
+
+      def build_field_set(selections, root: false)
+        return EMPTY_FIELD_SET if selections.empty?
+
+        fields = selections.map do |node|
+          raise CompositionError, "Key selections must be fields." unless node.is_a?(GraphQL::Language::Nodes::Field)
+          raise CompositionError, "Key fields may not specify aliases." unless node.alias.nil?
+
+          KeyField.new(node.name, inner: build_field_set(node.selections), root: root)
+        end
+
+        KeyFieldSet.new(fields)
+      end
+
+      def field_set_matches_type?(field_set, subgraph_type)
+        subgraph_type = subgraph_type.unwrap
+        field_set.all? do |field|
+          # fixme: union doesn't have fields, but may support these selections...
+          next true if subgraph_type.kind.union?
+          field_matches_type?(field, subgraph_type.get_field(field.name)&.type&.unwrap)
+        end
+      end
+
+      def field_matches_type?(field, subgraph_type)
+        return false if subgraph_type.nil?
+
+        if field.inner.empty? && subgraph_type.kind.composite?
+          raise CompositionError, "Composite key fields must contain nested selections."
+        end
+
+        field.inner.empty? || field_set_matches_type?(field.inner, subgraph_type)
+      end
+
+      def assign_field_set_info!(field_set, subgraph_type)
+        subgraph_type = subgraph_type.unwrap
+        field_set.each do |field|
+          # fixme: union doesn't have fields, but may support these selections...
+          next if subgraph_type.kind.union?
+          assign_field_info!(field, subgraph_type.get_field(field.name).type)
+        end
+      end
+
+      def assign_field_info!(field, subgraph_type)
+        field.list = subgraph_type.list?
+        field.type_name = subgraph_type.unwrap.graphql_name
+        assign_field_set_info!(field.inner, subgraph_type)
+      end
+    end
+  end
+end

data/lib/graphql/stitching/resolver.rb

@@ -1,47 +1,68 @@
 # frozen_string_literal: true
 
+require_relative "./resolver/arguments"
+require_relative "./resolver/keys"
+
 module GraphQL
   module Stitching
     # Defines a root resolver query that provides direct access to an entity type.
-    Resolver = Struct.new(
+    class Resolver
+      extend ArgumentsParser
+      extend KeysParser
+
       # location name providing the resolver query.
-      :location,
+      attr_reader :location
 
       # name of merged type fulfilled through this resolver.
-      :type_name,
+      attr_reader :type_name
+
+      # name of the root field to query.
+      attr_reader :field
 
       # a key field to select from prior locations, sent as resolver argument.
-      :key,
+      attr_reader :key
 
-      # name of the root field to query.
-      :field,
+      # parsed resolver Argument structures.
+      attr_reader :arguments
 
-      # specifies when the resolver is a list query.
-      :list,
+      def initialize(
+        location:,
+        type_name: nil,
+        list: false,
+        field: nil,
+        key: nil,
+        arguments: nil
+      )
+        @location = location
+        @type_name = type_name
+        @list = list
+        @field = field
+        @key = key
+        @arguments = arguments
+      end
 
-      # name of the root field argument used to send the key.
-      :arg,
+      # specifies when the resolver is a list query.
+      def list?
+        @list
+      end
 
-      # type name of the root field argument used to send the key.
-      :arg_type_name,
+      def version
+        @version ||= Digest::SHA2.hexdigest(as_json.to_json)
+      end
 
-      # specifies that keys should be sent as JSON representations with __typename and key.
-      :representations,
-      keyword_init: true
-    ) do
-      alias_method :list?, :list
-      alias_method :representations?, :representations
+      def ==(other)
+        self.class == other.class && self.as_json == other.as_json
+      end
 
       def as_json
         {
           location: location,
           type_name: type_name,
-          key: key,
+          list: list?,
           field: field,
-          list: list,
-          arg: arg,
-          arg_type_name: arg_type_name,
-          representations: representations,
+          key: key.to_definition,
+          arguments: arguments.map(&:to_definition).join(", "),
+          argument_types: arguments.map(&:to_type_definition).join(", "),
         }.tap(&:compact!)
       end
     end

data/lib/graphql/stitching/shaper.rb

@@ -23,8 +23,8 @@ module GraphQL
       def resolve_object_scope(raw_object, parent_type, selections, typename = nil)
         return nil if raw_object.nil?
 
-        typename ||= raw_object[ExportSelection.typename_node.alias]
-        raw_object.reject! { |key, _v| ExportSelection.key?(key) }
+        typename ||= raw_object[Resolver::TYPENAME_EXPORT_NODE.alias]
+        raw_object.reject! { |key, _v| Resolver.export_key?(key) }
 
         selections.each do |node|
           case node
@@ -64,7 +64,7 @@ module GraphQL
             return nil if result.nil?
 
           else
-            raise "Unexpected node of type #{node.class.name} in selection set."
+            raise StitchingError, "Unexpected node of type #{node.class.name} in selection set."
           end
         end
 

data/lib/graphql/stitching/skip_include.rb

@@ -40,7 +40,7 @@ module GraphQL
           end
 
           if filtered_selections.none?
-            filtered_selections << ExportSelection.typename_node
+            filtered_selections << Resolver::TYPENAME_EXPORT_NODE
           end
 
           if changed

data/lib/graphql/stitching/supergraph/key_directive.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module GraphQL::Stitching
+  class Supergraph
+    class KeyDirective < GraphQL::Schema::Directive
+      graphql_name "key"
+      locations OBJECT, INTERFACE, UNION
+      argument :key, String, required: true
+      argument :location, String, required: true
+      repeatable true
+    end
+  end
+end

data/lib/graphql/stitching/supergraph/resolver_directive.rb

@@ -5,14 +5,13 @@ module GraphQL::Stitching
     class ResolverDirective < GraphQL::Schema::Directive
       graphql_name "resolver"
       locations OBJECT, INTERFACE, UNION
-      argument :type_name, String, required: false
       argument :location, String, required: true
+      argument :list, Boolean, required: false
       argument :key, String, required: true
       argument :field, String, required: true
-      argument :arg, String, required: true
-      argument :arg_type_name, String, required: true
-      argument :list, Boolean, required: false
-      argument :representations, Boolean, required: false
+      argument :arguments, String, required: true
+      argument :argument_types, String, required: true
+      argument :type_name, String, required: false
       repeatable true
     end
   end