graph_weaver 0.4.0 → 0.4.6

data/lib/graph_weaver/codegen.rb

@@ -175,14 +175,26 @@ class GraphWeaver::Codegen
     @fragments = fragments
 
     unions = names.uniq.sort.map do |name|
+      class_name = camelize(name)
+      # the query module aliases <class_name> = <unions module>::<class_name>;
+      # a name that camelizes to a generated module-level constant (the Result
+      # struct, the QUERY heredoc) would collide with that alias at load
+      if HOISTED_UNION_RESERVED.include?(class_name)
+        raise GraphWeaver::Error,
+          "shared fragment #{name.inspect} hoists to #{class_name}, which collides with a generated constant — rename the fragment"
+      end
       fragment = fragments.fetch(name)
       type = @schema.get_type(fragment.type.name)
-      UnionNode.new(camelize(name), union_members(type, fragment.selections))
+      UnionNode.new(class_name, union_members(type, fragment.selections))
     end
 
     emit_unions_file(unions)
   end
 
+  # module-level constants every generated query module defines — a hoisted
+  # union aliased to one of these would clash at load
+  HOISTED_UNION_RESERVED = %w[Result QUERY].to_set.freeze
+
   VarDef = Struct.new(:kwarg, :wire, :node, :required)
 
   # Names that cannot appear bare in generated Ruby: keywords aren't
@@ -246,6 +258,15 @@ class GraphWeaver::Codegen
       VarDef.new(kwarg, var.name, node, required)
     end
 
+    # two variables that underscore to the same kwarg ($userId + $user_id) would
+    # silently drop one on the wire — flag it like a prop collision
+    collision = variables.group_by(&:kwarg).find { |_, vars| vars.size > 1 }
+    if collision
+      wire = collision.last.map { |var| "$#{var.wire}" }.join(", ")
+      raise GraphWeaver::Error,
+        "variables #{wire} both map to the kwarg '#{collision.first}:' — rename one"
+    end
+
     root = object_node(root_type, operation.selections, "Result")
 
     emit_module(root, variables)
@@ -270,8 +291,7 @@ class GraphWeaver::Codegen
 
     return if schema.get_type(name)
 
-    suggestion = defined?(DidYouMean::SpellChecker) &&
-      DidYouMean::SpellChecker.new(dictionary: schema.types.keys).correct(name).first
+    suggestion = GraphWeaver.did_you_mean(schema.types.keys, name)
     hint = suggestion ? " — did you mean '#{suggestion}'?" : ""
     # the type registry is reached via extend_type; scalars/enums via register_*
     method = kind == "type" ? "extend_type" : "register_#{kind}"
@@ -367,14 +387,6 @@ class GraphWeaver::Codegen
   end
 
 
-  # Selection#each_field, collected by result key (codegen groups
-  # repeated selections of one field so it can merge them)
-  def gather(type, selections)
-    out = {}
-    each_field(type, selections) { |key, node| (out[key] ||= []) << node }
-    out
-  end
-
   def object_node(type, selections, class_name)
     node = ObjectNode.new(class_name)
     node.graphql_type = type.graphql_name
@@ -465,20 +477,165 @@ class GraphWeaver::Codegen
       node.fields << ObjectNode::Field.new(prop, key, child)
     end
 
+    node.aliases = resolve_aliases(node)
     node
   end
 
-  # The concrete type conditions a selection mentions (inline fragments
-  # and named spreads), minus conditions naming the abstract type itself.
-  def concrete_conditions(core, selections)
-    selections.filter_map do |selection|
+  # Resolve each registered alias (extend_type alias:) for this struct's type
+  # against its actual selection — path -> a typed delegator emitted into the
+  # struct body. Validated here, per query, so an unselected or untraversable
+  # path fails at generation with a pointed message.
+  def resolve_aliases(node)
+    type_aliases(node.graphql_type).filter_map do |name, spec|
+      # a bad accessor name (reserved, or colliding with a real field) is a
+      # registration mistake — it fails for every query, so it always raises,
+      # even for optional aliases (which otherwise mask it as "doesn't fit").
+      check_alias_name!(node, name)
+      begin
+        resolve_alias(node, name, spec[:segments])
+      rescue GraphWeaver::Error
+        # a path that doesn't fit THIS query's selection: strict raises,
+        # optional simply omits the accessor
+        raise unless spec[:optional]
+      end
+    end
+  end
+
+  def check_alias_name!(node, name)
+    if node.fields.any? { |f| f.prop == name } || ALIAS_RESERVED.include?(name)
+      raise GraphWeaver::Error,
+        "alias #{name.inspect} on #{node.graphql_type} collides with an existing field or method"
+    end
+  end
+
+  # Registered aliases for a GraphQL type: global registry plus this client's
+  # overlay (client-scoped wins on a name clash).
+  def type_aliases(graphql_name)
+    global = GraphWeaver::Codegen.type_registry[graphql_name]&.dig(:aliases) || {}
+    (global.merge(@types[graphql_name]&.dig(:aliases) || {}))
+  end
+
+  ALIAS_RESERVED = (%w[from_h serialize to_h].to_set + RUBY_KEYWORDS).freeze
+  # list selectors — pick one element out of a list-typed hop, always nilable
+  # (the list may be empty). Everything else is a field prop.
+  LIST_SELECTORS = %w[first last].freeze
+
+  # Walk a dotted path through this struct's selected shape, building the
+  # delegator expression (`meta&.tag`, `_entities.first&.name`) and its return
+  # type. A segment is a field prop, or `first`/`last` to pick a list element.
+  # Everything is checked against the node tree: a field on a non-object, a
+  # selector on a non-list, or an unselected segment raises. Any nilable hop
+  # (a nullable field, or a list element) makes the accessor nilable.
+  def resolve_alias(node, name, segments)
+    cur = T.let(node, T.untyped)           # the node the path has reached
+    cur_nilable = T.let(false, T::Boolean) # is the expression so far nilable
+    nilable = T.let(false, T::Boolean)     # is the accessor overall nilable
+    containers = T.let([], T::Array[String]) # nested-struct class names on the way to the leaf
+    expr = +""
+
+    segments.each do |seg|
+      connector = expr.empty? ? "" : (cur_nilable ? "&." : ".")
+
+      # `first`/`last` select an element only when the current hop is actually a
+      # list; otherwise they're an ordinary field (a schema field named `first`)
+      if LIST_SELECTORS.include?(seg) && list_of(cur)
+        expr << connector << seg
+        cur = list_of(cur).of
+        cur_nilable = true # first/last is nil on an empty list
+        nilable = true
+      else
+        obj = object_of(cur)
+        unless obj
+          hint = if list_of(cur)
+            " — use .first or .last to pick an element"
+          elsif LIST_SELECTORS.include?(seg)
+            " — .#{seg} needs a list"
+          else
+            ""
+          end
+          raise GraphWeaver::Error,
+            "alias #{name.inspect} on #{node.graphql_type}: '#{seg}' can't be read here (not an object)#{hint}"
+        end
+        # the object a field is read from is the lexical container of its result
+        # (nested structs emit inside their parent); the aliased struct itself is
+        # the delegator's own scope, so it contributes no prefix
+        containers << obj.class_name unless obj.equal?(node)
+        field = obj.fields.find { |f| f.prop == seg }
+        unless field
+          props = obj.fields.map(&:prop)
+          suggestion = GraphWeaver.did_you_mean(props, seg)
+          hint = suggestion ? " — did you mean '#{suggestion}'?" : " (have: #{props.join(", ")})"
+          raise GraphWeaver::Error,
+            "alias #{name.inspect} on #{node.graphql_type}: '#{seg}' is not a selected field#{hint}"
+        end
+        expr << connector << seg
+        cur = field.node
+        cur_nilable = !field.node.non_null?
+        nilable ||= cur_nilable
+      end
+    end
+
+    leaf = qualified_alias_type(cur, containers)
+    type = nilable && leaf != "T.untyped" ? "T.nilable(#{leaf})" : leaf
+    ObjectNode::Alias.new(name, expr, type)
+  end
+
+  # The leaf's Sorbet type as referenced from the aliased struct. Generated
+  # nested constants (structs, enums, unions) must carry the container path,
+  # since the delegator's `sig` is emitted in an outer struct where a bare
+  # `Sub` wouldn't resolve; scalars, mapped enums, and hoisted union refs are
+  # already top-level. `containers` is the class-name chain to the leaf.
+  def qualified_alias_type(node, containers)
+    node = node.of if node.is_a?(NonNull)
+    prefix = containers.empty? ? "" : "#{containers.join("::")}::"
+
+    case node
+    when List
+      element = node.of.is_a?(NonNull) ? qualified_alias_type(node.of, containers) : begin
+        inner = qualified_alias_type(node.of, containers)
+        inner == "T.untyped" ? inner : "T.nilable(#{inner})"
+      end
+      "T::Array[#{element}]"
+    when ObjectNode, EnumNode, NarrowedNode then "#{prefix}#{node.class_name}"
+    when UnionNode then "#{prefix}#{node.bare_type}"
+    else node.bare_type # Scalar, MappedEnum, UnionRefNode — already top-level
+    end
+  end
+
+  # the List a node wraps (through NON_NULL), or nil
+  def list_of(node)
+    node = T.let(node, T.untyped)
+    node = node.of while node.is_a?(NonNull)
+    node if node.is_a?(List)
+  end
+
+  # the ObjectNode a node resolves to for field access (through NON_NULL and a
+  # narrowed abstract member), or nil — unions/scalars/lists can't be read into
+  def object_of(node)
+    node = T.let(node, T.untyped)
+    node = node.of while node.is_a?(NonNull)
+    node = node.nested if node.is_a?(NarrowedNode)
+    node if node.is_a?(ObjectNode)
+  end
+
+  # The concrete type conditions a selection mentions, minus conditions naming
+  # the abstract type itself — recursing into named-fragment and inline bodies,
+  # so a `... on X` nested inside a spread (`{ ...NodeFields }` where NodeFields
+  # holds `... on X`) still drives dispatch instead of being silently dropped.
+  def concrete_conditions(core, selections, visiting = Set.new)
+    selections.flat_map do |selection|
       case selection
       when GraphQL::Language::Nodes::InlineFragment
-        selection.type&.name
+        [selection.type&.name, *concrete_conditions(core, selection.selections, visiting)]
       when GraphQL::Language::Nodes::FragmentSpread
-        @fragments.fetch(selection.name).type.name
+        next [] if visiting.include?(selection.name)
+
+        fragment = @fragments.fetch(selection.name)
+        [fragment.type.name, *concrete_conditions(core, fragment.selections, visiting | [selection.name])]
+      else
+        []
       end
-    end.uniq - [core.graphql_name]
+    end.compact.uniq - [core.graphql_name]
   end
 
   # result keys selected as plain fields (outside any type condition)

data/lib/graph_weaver/hints.rb

@@ -28,8 +28,8 @@ module GraphWeaver
         prop = GraphWeaver::Inflect.underscore(key)
         suggestion = if known.include?(prop)
           prop # a wire-cased key — the exact snake_case prop exists
-        elsif defined?(DidYouMean::SpellChecker)
-          DidYouMean::SpellChecker.new(dictionary: known).correct(prop).first
+        else
+          GraphWeaver.did_you_mean(known, prop)
         end
         suggestion ? "#{key} (did you mean '#{suggestion}'?)" : key
       end
@@ -56,12 +56,10 @@ module GraphWeaver
         return "GraphQL fields generate snake_case props; use '#{prop}'"
       end
 
-      return unless defined?(DidYouMean::SpellChecker)
-
       # a guess, not a mapping — spellcheck the (underscored) miss
       # against the props that exist, so typos in either casing land
       props = T.unsafe(self.class).props.keys.map(&:to_s)
-      suggestion = DidYouMean::SpellChecker.new(dictionary: props).correct(prop).first
+      suggestion = GraphWeaver.did_you_mean(props, prop)
       "did you mean '#{suggestion}'?" if suggestion
     end
   end

data/lib/graph_weaver/input_struct.rb

@@ -46,6 +46,13 @@ module GraphWeaver
       def coerce(value)
         return value if value.is_a?(self)
 
+        # a caller passing a non-Hash (a bare string, or a Hash where a nested
+        # list was expected) is bad input — surface a branded 422, not a raw
+        # NoMethodError from validate_keys!'s `.keys`
+        unless value.is_a?(Hash)
+          raise GraphWeaver::InputError.new("expected a Hash or #{self}, got #{value.class}", struct: self)
+        end
+
         # a typo'd key must not silently drop off the wire
         GraphWeaver::Hints.validate_keys!(self, value)
 

data/lib/graph_weaver/response.rb

@@ -49,7 +49,14 @@ module GraphWeaver
     sig { returns(Data) }
     def data!
       raise GraphWeaver::QueryError.new(errors, data: data, extensions: extensions) unless errors.empty?
-      T.must(data)
+
+      # a well-formed GraphQL response always pairs null data with errors; a
+      # server (or an errors-stripping proxy) that returns neither is broken —
+      # brand it rather than leaking a bare `T.must` TypeError
+      data || raise(GraphWeaver::QueryError.new(
+        [GraphWeaver::GraphQLError.new(message: "response carried neither data nor errors")],
+        extensions: extensions,
+      ))
     end
   end
 end

data/lib/graph_weaver/schema_loader.rb

@@ -26,19 +26,179 @@ module GraphWeaver::SchemaLoader
         raise ArgumentError, "unsupported schema content: #{source.lstrip[0, 80].inspect}"
       end
 
-      GraphQL::Schema.from_definition(source)
+      build_sdl(source)
     else # a file path
       case File.extname(source)
       when ".json"
         GraphQL::Schema.from_introspection(JSON.parse(File.read(source)))
       when ".graphql", ".gql"
-        GraphQL::Schema.from_definition(File.read(source))
+        build_sdl(File.read(source))
       else
         raise ArgumentError, "unsupported schema format: #{source}"
       end
     end
   end
 
+  # Build a schema from SDL, first stripping Apollo Federation composition
+  # machinery when the SDL is a composed supergraph — so a supergraph dump
+  # (often the only artifact for the merged graph, and what the router
+  # actually serves) loads like any schema, with the federation plumbing
+  # gone rather than leaked into schema.types. Plain SDL passes through.
+  def self.build_sdl(sdl)
+    GraphQL::Schema.from_definition(federation_sdl?(sdl) ? strip_federation(sdl) : sdl)
+  end
+  private_class_method :build_sdl
+
+  # A composed Fed2 supergraph is marked by @join__* directives (every merged
+  # type carries them); a plain schema has none.
+  def self.federation_sdl?(sdl)
+    sdl.match?(/@join__\w/)
+  end
+
+  FEDERATION_PREFIXES = %w[join__ link__ core__].freeze
+  FEDERATION_DIRECTIVES = %w[link core inaccessible].to_set.freeze
+
+  # Synthetic composition TYPES are always prefixed (join__Graph, link__Import).
+  # The bare names (link/core/inaccessible) are DIRECTIVES only — a user type
+  # literally named `link` (Hasura-style lowercase) must not be dropped.
+  def self.federation_type_name?(name)
+    !!name && name.start_with?(*FEDERATION_PREFIXES)
+  end
+  private_class_method :federation_type_name?
+
+  def self.federation_directive_name?(name)
+    !!name && (name.start_with?(*FEDERATION_PREFIXES) || FEDERATION_DIRECTIVES.include?(name))
+  end
+  private_class_method :federation_directive_name?
+
+  # Drop the composition machinery from supergraph SDL: the synthetic
+  # join__*/link__* type and directive definitions, and every @join__*/@link
+  # application on the types that remain. What's left is the merged graph's
+  # ordinary type shapes — exactly what codegen reads. Parsing is lenient (it's
+  # schema *building* that rejects the join directives), so we parse, filter the
+  # AST, and reprint clean SDL for from_definition — no graphql-ruby monkeypatch
+  # and no join__* leaking into schema.types.
+  def self.strip_federation(sdl)
+    doc = GraphQL.parse(sdl)
+    defs = remove_inaccessible(doc.definitions)
+      .reject { |defn| federation_definition?(defn) }
+      .map { |defn| strip_federation_directives(defn) }
+
+    if defs.none? { |d| d.is_a?(GraphQL::Language::Nodes::ObjectTypeDefinition) }
+      raise GraphWeaver::Error,
+        "supergraph has no object types left after stripping the federation machinery — " \
+        "is the whole schema behind @inaccessible?"
+    end
+
+    GraphQL::Language::Nodes::Document.new(definitions: defs).to_query_string
+  end
+
+  # a synthetic composition definition to drop: a federation directive
+  # definition (by name), or a synthetic join__*/link__* type (by prefix)
+  def self.federation_definition?(defn)
+    return false unless defn.respond_to?(:name)
+
+    if defn.is_a?(GraphQL::Language::Nodes::DirectiveDefinition)
+      federation_directive_name?(defn.name)
+    else
+      federation_type_name?(defn.name)
+    end
+  end
+  private_class_method :federation_definition?
+
+  # Derive the API schema by dropping every element marked @inaccessible —
+  # present in the federated graph but hidden from the public API the router
+  # serves (its common use is safely rolling out a field on a shared type).
+  # Cascades: a field/argument/union-member/implements referencing a removed
+  # type goes too, and a type left with no fields/values/members is itself
+  # removed — repeated to a fixpoint. So codegen matches exactly what clients
+  # can query, without the over-permitting a raw supergraph would allow and
+  # without Apollo's JS tooling to subtract the API schema.
+  def self.remove_inaccessible(definitions)
+    removed = definitions.select { |d| type_definition?(d) && inaccessible?(d) }.map(&:name).to_set
+    loop do
+      survivors = definitions
+        .reject { |d| type_definition?(d) && removed.include?(d.name) }
+        .map { |d| prune_inaccessible(d, removed) }
+      # survivors already exclude `removed`, so anything newly emptied is fresh
+      newly = survivors.select { |d| type_definition?(d) && type_emptied?(d) }.map(&:name)
+      return survivors if newly.empty?
+
+      removed.merge(newly)
+    end
+  end
+  private_class_method :remove_inaccessible
+
+  # A type-system type definition (object/interface/union/enum/input/scalar) —
+  # not a directive or schema definition.
+  def self.type_definition?(node)
+    node.respond_to?(:name) &&
+      !node.is_a?(GraphQL::Language::Nodes::DirectiveDefinition) &&
+      node.class.name.end_with?("TypeDefinition")
+  end
+  private_class_method :type_definition?
+
+  def self.inaccessible?(node)
+    node.respond_to?(:directives) && node.directives.any? { |d| d.name == "inaccessible" }
+  end
+  private_class_method :inaccessible?
+
+  # Whether pruning left the type with nothing the SDL grammar allows to be
+  # empty — a fieldless object/interface/input, a valueless enum, a memberless
+  # union — so it must be removed and its references cascaded.
+  def self.type_emptied?(node)
+    (node.respond_to?(:fields) && node.fields && node.fields.empty?) ||
+      (node.is_a?(GraphQL::Language::Nodes::EnumTypeDefinition) && node.values.empty?) ||
+      (node.is_a?(GraphQL::Language::Nodes::UnionTypeDefinition) && node.types.empty?)
+  end
+  private_class_method :type_emptied?
+
+  # the unwrapped (through NON_NULL/LIST) type name a field or argument references
+  def self.unwrapped_type_name(node)
+    type = node.type
+    type = type.of_type while type.respond_to?(:of_type)
+    type.name
+  end
+  private_class_method :unwrapped_type_name
+
+  # Remove @inaccessible children and children referencing a removed type,
+  # from a type's fields (and their arguments), enum values, union members,
+  # and implemented interfaces.
+  def self.prune_inaccessible(node, removed)
+    gone = lambda do |child|
+      inaccessible?(child) || (child.respond_to?(:type) && removed.include?(unwrapped_type_name(child)))
+    end
+
+    changes = {}
+    if node.respond_to?(:fields) && node.fields
+      changes[:fields] = node.fields.reject(&gone).map do |field|
+        args = field.respond_to?(:arguments) && field.arguments
+        args && args.any? ? field.merge(arguments: args.reject(&gone)) : field
+      end
+    end
+    changes[:values] = node.values.reject(&gone) if node.respond_to?(:values) && node.values
+    changes[:types] = node.types.reject { |t| removed.include?(t.name) } if node.respond_to?(:types) && node.types
+    if node.respond_to?(:interfaces) && node.interfaces
+      changes[:interfaces] = node.interfaces.reject { |i| removed.include?(i.name) }
+    end
+    changes.empty? ? node : node.merge(changes)
+  end
+  private_class_method :prune_inaccessible
+
+  # Recursively remove @join__*/@link applications from a definition and its
+  # fields, arguments, and enum values.
+  def self.strip_federation_directives(node)
+    changes = {}
+    if node.respond_to?(:directives) && node.directives
+      changes[:directives] = node.directives.reject { |d| federation_directive_name?(d.name) }
+    end
+    changes[:fields] = node.fields.map { |c| strip_federation_directives(c) } if node.respond_to?(:fields) && node.fields
+    changes[:arguments] = node.arguments.map { |c| strip_federation_directives(c) } if node.respond_to?(:arguments) && node.arguments
+    changes[:values] = node.values.map { |c| strip_federation_directives(c) } if node.respond_to?(:values) && node.values
+    changes.empty? ? node : node.merge(changes)
+  end
+  private_class_method :strip_federation_directives
+
   # Run the standard introspection query through a transport and build a
   # schema from the result:
   #

data/lib/graph_weaver/selection.rb

@@ -34,24 +34,41 @@ module GraphWeaver
     # Flatten a selection set as seen by `type`, yielding (result_key,
     # field_node) per field: plain fields yield directly; inline fragments
     # and named spreads recurse when their type condition applies.
-    def each_field(type, selections, &block)
+    def each_field(type, selections, visiting = Set.new, &block)
       selections.each do |selection|
         case selection
         when GraphQL::Language::Nodes::Field
           yield(selection.alias || selection.name, selection)
         when GraphQL::Language::Nodes::InlineFragment
-          each_field(type, selection.selections, &block) if applies?(selection.type&.name, type)
+          each_field(type, selection.selections, visiting, &block) if applies?(selection.type&.name, type)
         when GraphQL::Language::Nodes::FragmentSpread
           fragment = @fragments.fetch(selection.name) do
             raise ArgumentError, "unknown fragment: #{selection.name}"
           end
-          each_field(type, fragment.selections, &block) if applies?(fragment.type.name, type)
+          if visiting.include?(selection.name)
+            raise GraphWeaver::Error, "fragment cycle through #{selection.name}"
+          end
+
+          if applies?(fragment.type.name, type)
+            each_field(type, fragment.selections, visiting | [selection.name], &block)
+          end
         else
           raise GraphWeaver::Error, "unsupported selection: #{selection.class}"
         end
       end
     end
 
+    # each_field grouped by result key: repeated selections of one field
+    # (`a { x } a { y }`, or the same field reached through two fragments)
+    # collect together, so callers MERGE their sub-selections rather than
+    # last-writer-wins. Codegen relies on this; FakeClient/Anonymizer must too,
+    # or they'd fabricate/keep a shape the generated struct can't cast.
+    def gather(type, selections)
+      out = {}
+      each_field(type, selections) { |key, node| (out[key] ||= []) << node }
+      out
+    end
+
     # A fragment's type condition applies when it names this type exactly,
     # or an interface/union this type belongs to (`... on Named { ... }`).
     def applies?(condition, type)

data/lib/graph_weaver/testing/cassette.rb

@@ -70,7 +70,7 @@ module GraphWeaver
         entry = {
           "key" => self.class.key(query, variables),
           "query" => query,
-          "variables" => variables,
+          "variables" => self.class.normalize_variables(variables),
           "response" => response,
         }
         @entries.reject! { |existing| existing["key"] == entry["key"] }
@@ -92,7 +92,14 @@ module GraphWeaver
       end
 
       def self.key(query, variables)
-        { "query" => query.gsub(/\s+/, " ").strip, "variables" => variables || {} }
+        { "query" => query.gsub(/\s+/, " ").strip, "variables" => normalize_variables(variables) }
+      end
+
+      # JSON round-trip so symbol keys become strings — otherwise YAML.dump
+      # writes Ruby symbols the safe loader rejects on the next run, and lookup
+      # keys stay stable across processes
+      def self.normalize_variables(variables)
+        JSON.parse(JSON.generate(variables || {}))
       end
 
       private
@@ -167,6 +174,19 @@ module GraphWeaver
 
       private
 
+      # Anonymization walks recorded data, not a live dispatch. When the query
+      # narrows an abstract type without selecting __typename (`named { name
+      # ... on Pet { species } }`), the recorded data has no type tag, so the
+      # strict applies? would drop the `... on Pet` fields. Treat any concrete
+      # member condition as applying; object_value's `data.key?(key)` guard
+      # discards fields the actual member's response didn't carry.
+      def applies?(condition, type)
+        return true if super
+
+        member = @schema.get_type(condition)
+        !!member && @schema.possible_types(type).include?(member)
+      end
+
       def object_value(type, selections, data)
         return data if data.nil?
 
@@ -190,7 +210,12 @@ module GraphWeaver
       end
 
       def field_value(parent_type, node, value)
-        type_value(@schema.get_field(parent_type.graphql_name, node.name).type, node, value)
+        # a field from a `... on Member` fragment lives on the member, not the
+        # abstract type we're walking (no __typename to narrow by), so fall back
+        # to whichever possible type declares it
+        field = @schema.get_field(parent_type.graphql_name, node.name) ||
+          @schema.possible_types(parent_type).filter_map { |t| @schema.get_field(t.graphql_name, node.name) }.first
+        type_value(field.type, node, value)
       end
 
       def type_value(type, node, value)

data/lib/graph_weaver/testing/fake_client.rb

@@ -73,6 +73,8 @@ class GraphWeaver::Testing::FakeClient
 
     @path = []
     @failures = []
+    # fail_at fires once per execute, not once per client lifetime
+    @fail_at.each { |spec| spec.delete("triggered") }
     data = object_value(root_type, operation.selections)
     data = nil if data.equal?(NULL_BUBBLE) # total propagation, like a real server
 
@@ -104,9 +106,12 @@ class GraphWeaver::Testing::FakeClient
 
   def object_value(type, selections)
     result = {}
-    each_field(type, selections) do |key, node|
+    # gather (not each_field) so a field selected twice — `a { x } a { y }` —
+    # fabricates the MERGED shape codegen's struct expects, not last-writer-wins
+    gather(type, selections).each do |key, nodes|
+      node = nodes.first
       @path.push(key)
-      value = node.name == "__typename" ? type.graphql_name : field_value(type, node)
+      value = node.name == "__typename" ? type.graphql_name : field_value(type, node, nodes.flat_map(&:selections))
       @path.pop
 
       if value.equal?(NULL_BUBBLE)
@@ -127,7 +132,7 @@ class GraphWeaver::Testing::FakeClient
     @schema.get_field(type.graphql_name, node.name).type.kind.name == "NON_NULL"
   end
 
-  def field_value(parent_type, node)
+  def field_value(parent_type, node, selections)
     if (spec = matching_failure)
       @failures << {
         "message" => spec["message"] || "simulated failure",
@@ -148,7 +153,7 @@ class GraphWeaver::Testing::FakeClient
       return corrupt_value(field_type)
     end
 
-    type_value(field_type, node)
+    type_value(field_type, node, selections)
   end
 
   # a value casting can't accept, derived from the field's own type — and
@@ -181,17 +186,18 @@ class GraphWeaver::Testing::FakeClient
     argument = node.arguments.find { |arg| %w[first last limit].include?(arg.name) }
     return argument.value if argument && argument.value.is_a?(Integer)
 
-    rng.rand(@list_size)
+    # an Integer list_size means exactly that many; a Range randomizes within it
+    @list_size.is_a?(Range) ? rng.rand(@list_size) : @list_size
   end
 
-  def type_value(type, node, non_null: false)
+  def type_value(type, node, selections, non_null: false)
     case type.kind.name
     when "NON_NULL"
-      type_value(type.of_type, node, non_null: true)
+      type_value(type.of_type, node, selections, non_null: true)
     when "LIST"
       elements = Array.new(list_length(node)) do |index|
         @path.push(index)
-        element = type_value(type.of_type, node)
+        element = type_value(type.of_type, node, selections)
         @path.pop
         element
       end
@@ -206,21 +212,21 @@ class GraphWeaver::Testing::FakeClient
     else
       return if !non_null && rng.rand < @null_chance
 
-      core_value(type, node)
+      core_value(type, node, selections)
     end
   end
 
-  def core_value(type, node)
+  def core_value(type, node, selections)
     case type.kind.name
     when "SCALAR"
       @values.scalar(type.graphql_name, node.name)
     when "ENUM"
       type.values.keys.sort.sample(random: rng)
     when "OBJECT"
-      object_value(type, node.selections)
+      object_value(type, selections)
     when "UNION", "INTERFACE"
       member = @schema.possible_types(type).sort_by(&:graphql_name).sample(random: rng)
-      object_value(member, node.selections)
+      object_value(member, selections)
     else
       raise NotImplementedError, "cannot fake kind: #{type.kind.name}"
     end