graph_weaver 0.7.4 → 0.7.6

data/lib/graph_weaver/codegen/nodes.rb

@@ -113,11 +113,11 @@ class GraphWeaver::Codegen
 
     def cast(expr, depth)
       var = "v#{depth}"
-      element = if @of.non_null? || @of.identity?
-        @of.identity? ? var : @of.cast(var, depth + 1)
-      else
-        "#{var}&.then { |v#{depth + 1}| #{@of.cast("v#{depth + 1}", depth + 2)} }"
-      end
+      element =
+        if @of.identity? then var
+        elsif @of.non_null? then @of.cast(var, depth + 1)
+        else "#{var}&.then { |v#{depth + 1}| #{@of.cast("v#{depth + 1}", depth + 2)} }"
+        end
 
       "#{expr}.map { |#{var}| #{element} }"
     end
@@ -127,11 +127,11 @@ class GraphWeaver::Codegen
 
     def serialize(expr, depth)
       var = "v#{depth}"
-      element = if @of.non_null? || @of.serialize_identity?
-        @of.serialize_identity? ? var : @of.serialize(var, depth + 1)
-      else
-        "#{var}&.then { |v#{depth + 1}| #{@of.serialize("v#{depth + 1}", depth + 2)} }"
-      end
+      element =
+        if @of.serialize_identity? then var
+        elsif @of.non_null? then @of.serialize(var, depth + 1)
+        else "#{var}&.then { |v#{depth + 1}| #{@of.serialize("v#{depth + 1}", depth + 2)} }"
+        end
 
       "#{expr}.map { |#{var}| #{element} }"
     end
@@ -153,11 +153,11 @@ class GraphWeaver::Codegen
 
     def hash_coerce(expr, depth)
       var = "v#{depth}"
-      inner = if @of.non_null? || @of.hash_coerce_identity?
-        @of.hash_coerce_identity? ? var : @of.hash_coerce(var, depth + 1)
-      else
-        "#{var}&.then { |v#{depth + 1}| #{@of.hash_coerce("v#{depth + 1}", depth + 2)} }"
-      end
+      inner =
+        if @of.hash_coerce_identity? then var
+        elsif @of.non_null? then @of.hash_coerce(var, depth + 1)
+        else "#{var}&.then { |v#{depth + 1}| #{@of.hash_coerce("v#{depth + 1}", depth + 2)} }"
+        end
       return "#{expr}.map { |#{var}| #{inner} }" if hash_coerce_identity?
 
       # the index is a path segment — `where._and.0._not.species` needs the 0
@@ -207,10 +207,13 @@ class GraphWeaver::Codegen
   class EnumNode < Node
     attr_reader :class_name, :values, :aliases
 
-    def initialize(class_name, values, aliases = {})
+    # fallback: the name of the member unknown wire values cast to (register_enum
+    # fallback: true), or nil for a strict enum
+    def initialize(class_name, values, aliases = {}, fallback: nil)
       @class_name = class_name
       @values = values
       @aliases = aliases
+      @fallback = fallback
     end
 
     def bare_type = class_name
@@ -220,10 +223,19 @@ class GraphWeaver::Codegen
     def aliased? = !@aliases.empty?
     def alias_const = "#{GraphWeaver::Inflect.underscore(class_name).upcase}_ALIASES"
 
+    # register_enum fallback: true — the extra member every value the schema
+    # doesn't declare casts to, and the one member a variable can't send
+    attr_reader :fallback
+    def fallback? = !@fallback.nil?
+    def fallback_const = "#{class_name}::#{@fallback}"
+
     def cast(expr, _depth)
-      "GraphWeaver::Hints.enum(#{class_name}, #{expr}#{", #{alias_const}" if aliased?})"
+      "GraphWeaver::Hints.enum(#{class_name}, #{expr}#{runtime_args})"
     end
 
+    # Other serializes to ENUM_FALLBACK_WIRE, which casts back to Other — so a
+    # result carrying it still round-trips through #as_json, even though no
+    # server would accept that spelling.
     def serialize(expr, _depth)
       "#{expr}.serialize"
     end
@@ -235,7 +247,11 @@ class GraphWeaver::Codegen
     def coerce? = true
 
     def coerce(expr)
-      "GraphWeaver::InputStruct.enum(#{class_name}, #{expr}#{", #{alias_const}" if aliased?})"
+      "GraphWeaver::InputStruct.enum(#{class_name}, #{expr}#{runtime_args})"
+    end
+
+    def runtime_args
+      "#{", #{alias_const}" if aliased?}#{", fallback: #{fallback_const}" if fallback?}"
     end
 
     def input_type = "T.any(#{class_name}, String)"
@@ -277,7 +293,9 @@ class GraphWeaver::Codegen
     # #as_json. Without a fallback the table is total and a miss is a real
     # mistake, so it still raises.
     def serialize(expr, _depth)
-      return "#{const_prefix}_TO_WIRE.fetch(#{expr})" unless @fallback
+      unless @fallback
+        return "GraphWeaver::InputStruct.enum_wire(#{@graphql_name.inspect}, #{const_prefix}_TO_WIRE, #{expr})"
+      end
 
       "#{const_prefix}_TO_WIRE.fetch(#{expr}) { |member| member.serialize }"
     end
@@ -358,20 +376,22 @@ class GraphWeaver::Codegen
     def nested = self
   end
 
-  # A reference to a union hoisted into the shared types module (a named
-  # shared fragment spread as a whole union field): the query references
-  # <Name>::Type and dispatches through <Name>.from_h, where <Name> is the
-  # alias the query module gives GraphQLTypes::<Name>. The type family lives
-  # once in the shared module, so the same union across queries is one Ruby
-  # type — nested is nil, nothing is emitted here.
-  class UnionRefNode < Node
-    attr_reader :class_name
-
-    def initialize(class_name)
+  # A reference to a type hoisted into the shared types module (a named shared
+  # fragment spread as a whole field): the query casts through <Name>.from_h,
+  # where <Name> is the alias the query module gives GraphQLTypes::<Name>. The
+  # type lives once in the shared module, so the same fragment across queries
+  # is one Ruby type — nested is nil, nothing is emitted here.
+  class HoistedRefNode < Node
+    # graphql_type is carried for refusals alone — an alias path that tries to
+    # read into the hoisted struct says which type to register itself on
+    attr_reader :class_name, :graphql_type
+
+    def initialize(class_name, graphql_type = nil)
       @class_name = class_name
+      @graphql_type = graphql_type
     end
 
-    def bare_type = "#{class_name}::Type"
+    def bare_type = class_name
 
     def cast(expr, _depth)
       "#{class_name}.from_h(#{expr})"
@@ -382,6 +402,29 @@ class GraphWeaver::Codegen
     end
   end
 
+  # The same, on an abstract type: the hoisted name is a dispatch module, so
+  # the Ruby type is its member union rather than the module itself.
+  class UnionRefNode < HoistedRefNode
+    def bare_type = "#{class_name}::Type"
+  end
+
+  # An abstract fragment narrowing to one member hoists to that member's
+  # struct, and narrowing filters — so the match is tested at the reference,
+  # the way NarrowedNode does it, rather than inside a T::Struct.from_h that
+  # has no way to answer nil. See NarrowedNode for what `typename` being
+  # absent means.
+  class NarrowedRefNode < HoistedRefNode
+    def initialize(class_name, graphql_type = nil, typename: nil)
+      super(class_name, graphql_type)
+      @typename = typename
+    end
+
+    def cast(expr, depth)
+      match = @typename ? "#{expr}[\"__typename\"] == #{@typename.inspect}" : "!#{expr}.empty?"
+      "(#{match} ? #{super} : nil)"
+    end
+  end
+
   # An input-object variable: emitted as a module-level T::Struct whose
   # serialize produces the wire hash. Inputs never cast FROM the wire.
   # Joins the coerce protocol so execute kwargs accept plain hashes,
@@ -454,6 +497,6 @@ class GraphWeaver::Codegen
   # The IR is codegen's own vocabulary — every node type is reachable only
   # from inside the walk.
   private_constant :Node, :Scalar, :NonNull, :List, :ObjectNode, :EnumNode,
-    :MappedEnum, :NarrowedNode, :UnionNode, :UnionRefNode, :InputNode,
-    :RepresentationNode
+    :MappedEnum, :NarrowedNode, :UnionNode, :HoistedRefNode, :UnionRefNode,
+    :NarrowedRefNode, :InputNode, :RepresentationNode
 end