graph_weaver 0.7.2 → 0.7.4

data/examples/github/generated/stargazers_query.rb

@@ -1,7 +1,7 @@
 # typed: strict
 # frozen_string_literal: true
 
-# Generated by GraphWeaver 0.7.2 — do not edit.
+# Generated by GraphWeaver 0.7.4 — do not edit.
 
 require "time"
 
@@ -85,6 +85,14 @@ module StargazersQuery
                 rescue StandardError => e
                   raise GraphWeaver::CastError.new(struct: self, message: GraphWeaver::Hints.cast_message(self, data, e))
                 end
+
+                sig { params(_options: T.untyped).returns(T::Hash[String, T.untyped]) }
+                def as_json(*_options)
+                  {
+                    "nameWithOwner" => name_with_owner,
+                    "stargazerCount" => stargazer_count,
+                  }
+                end
               end
 
               const :nodes, T.nilable(T::Array[T.nilable(Nodes)])
@@ -99,6 +107,13 @@ module StargazersQuery
               rescue StandardError => e
                 raise GraphWeaver::CastError.new(struct: self, message: GraphWeaver::Hints.cast_message(self, data, e))
               end
+
+              sig { params(_options: T.untyped).returns(T::Hash[String, T.untyped]) }
+              def as_json(*_options)
+                {
+                  "nodes" => nodes&.then { |v1| v1.map { |v2| v2&.then { |v3| v3.as_json } } },
+                }
+              end
             end
 
             const :login, String
@@ -117,6 +132,15 @@ module StargazersQuery
             rescue StandardError => e
               raise GraphWeaver::CastError.new(struct: self, message: GraphWeaver::Hints.cast_message(self, data, e))
             end
+
+            sig { params(_options: T.untyped).returns(T::Hash[String, T.untyped]) }
+            def as_json(*_options)
+              {
+                "login" => login,
+                "name" => name,
+                "repositories" => repositories.as_json,
+              }
+            end
           end
 
           const :starred_at, Time
@@ -125,7 +149,7 @@ module StargazersQuery
           sig { params(data: T::Hash[String, T.untyped]).returns(Edges) }
           def self.from_h(data)
             new(
-              starred_at: GraphWeaver::Hints.field(self, "starredAt") { Time.parse(data.fetch("starredAt")) },
+              starred_at: GraphWeaver::Hints.field(self, "starredAt") { Time.iso8601(data.fetch("starredAt")) },
               node: Node.from_h(data.fetch("node")),
             )
           rescue GraphWeaver::Error
@@ -133,6 +157,14 @@ module StargazersQuery
           rescue StandardError => e
             raise GraphWeaver::CastError.new(struct: self, message: GraphWeaver::Hints.cast_message(self, data, e))
           end
+
+          sig { params(_options: T.untyped).returns(T::Hash[String, T.untyped]) }
+          def as_json(*_options)
+            {
+              "starredAt" => GraphWeaver::Coerce.timestamp(starred_at),
+              "node" => node.as_json,
+            }
+          end
         end
 
         const :edges, T.nilable(T::Array[T.nilable(Edges)])
@@ -147,6 +179,13 @@ module StargazersQuery
         rescue StandardError => e
           raise GraphWeaver::CastError.new(struct: self, message: GraphWeaver::Hints.cast_message(self, data, e))
         end
+
+        sig { params(_options: T.untyped).returns(T::Hash[String, T.untyped]) }
+        def as_json(*_options)
+          {
+            "edges" => edges&.then { |v1| v1.map { |v2| v2&.then { |v3| v3.as_json } } },
+          }
+        end
       end
 
       const :id, String
@@ -167,6 +206,16 @@ module StargazersQuery
       rescue StandardError => e
         raise GraphWeaver::CastError.new(struct: self, message: GraphWeaver::Hints.cast_message(self, data, e))
       end
+
+      sig { params(_options: T.untyped).returns(T::Hash[String, T.untyped]) }
+      def as_json(*_options)
+        {
+          "id" => id,
+          "nameWithOwner" => name_with_owner,
+          "stargazerCount" => stargazer_count,
+          "stargazers" => stargazers.as_json,
+        }
+      end
     end
 
     const :repository, T.nilable(Repository)
@@ -181,6 +230,13 @@ module StargazersQuery
     rescue StandardError => e
       raise GraphWeaver::CastError.new(struct: self, message: GraphWeaver::Hints.cast_message(self, data, e))
     end
+
+    sig { params(_options: T.untyped).returns(T::Hash[String, T.untyped]) }
+    def as_json(*_options)
+      {
+        "repository" => repository&.then { |v1| v1.as_json },
+      }
+    end
   end
 
   # client — see GraphWeaver::QueryModule
@@ -196,9 +252,9 @@ module StargazersQuery
   sig { params(owner: String, name: String, first: Integer, client: T.untyped).returns(GraphWeaver::Response[Result]).checked(:never) }
   def self.execute(owner:, name:, first:, client: nil)
     variables = {
-      "owner" => GraphWeaver::Coerce.variable("owner", OPERATION_NAME, owner) { |v| GraphWeaver::Coerce.string(v) },
-      "name" => GraphWeaver::Coerce.variable("name", OPERATION_NAME, name) { |v| GraphWeaver::Coerce.string(v) },
-      "first" => GraphWeaver::Coerce.variable("first", OPERATION_NAME, first) { |v| GraphWeaver::Coerce.integer(v) },
+      "owner" => GraphWeaver::Coerce.variable("owner", OPERATION_NAME, owner) { |v| GraphWeaver::Coerce.string(v, "String") },
+      "name" => GraphWeaver::Coerce.variable("name", OPERATION_NAME, name) { |v| GraphWeaver::Coerce.string(v, "String") },
+      "first" => GraphWeaver::Coerce.variable("first", OPERATION_NAME, first) { |v| GraphWeaver::Coerce.integer(v, "Int") },
     }
 
     from_response(dispatch(variables, client:))

data/examples/github/generated/starred_query.rb

@@ -1,7 +1,7 @@
 # typed: strict
 # frozen_string_literal: true
 
-# Generated by GraphWeaver 0.7.2 — do not edit.
+# Generated by GraphWeaver 0.7.4 — do not edit.
 
 module StarredQuery
   extend T::Sig
@@ -57,6 +57,14 @@ module StarredQuery
           rescue StandardError => e
             raise GraphWeaver::CastError.new(struct: self, message: GraphWeaver::Hints.cast_message(self, data, e))
           end
+
+          sig { params(_options: T.untyped).returns(T::Hash[String, T.untyped]) }
+          def as_json(*_options)
+            {
+              "nameWithOwner" => name_with_owner,
+              "stargazerCount" => stargazer_count,
+            }
+          end
         end
 
         const :total_count, Integer
@@ -73,6 +81,14 @@ module StarredQuery
         rescue StandardError => e
           raise GraphWeaver::CastError.new(struct: self, message: GraphWeaver::Hints.cast_message(self, data, e))
         end
+
+        sig { params(_options: T.untyped).returns(T::Hash[String, T.untyped]) }
+        def as_json(*_options)
+          {
+            "totalCount" => total_count,
+            "nodes" => nodes&.then { |v1| v1.map { |v2| v2&.then { |v3| v3.as_json } } },
+          }
+        end
       end
 
       const :starred_repositories, StarredRepositories
@@ -87,6 +103,13 @@ module StarredQuery
       rescue StandardError => e
         raise GraphWeaver::CastError.new(struct: self, message: GraphWeaver::Hints.cast_message(self, data, e))
       end
+
+      sig { params(_options: T.untyped).returns(T::Hash[String, T.untyped]) }
+      def as_json(*_options)
+        {
+          "starredRepositories" => starred_repositories.as_json,
+        }
+      end
     end
 
     const :user, T.nilable(User)
@@ -101,6 +124,13 @@ module StarredQuery
     rescue StandardError => e
       raise GraphWeaver::CastError.new(struct: self, message: GraphWeaver::Hints.cast_message(self, data, e))
     end
+
+    sig { params(_options: T.untyped).returns(T::Hash[String, T.untyped]) }
+    def as_json(*_options)
+      {
+        "user" => user&.then { |v1| v1.as_json },
+      }
+    end
   end
 
   # client — see GraphWeaver::QueryModule
@@ -116,8 +146,8 @@ module StarredQuery
   sig { params(login: String, first: Integer, client: T.untyped).returns(GraphWeaver::Response[Result]).checked(:never) }
   def self.execute(login:, first:, client: nil)
     variables = {
-      "login" => GraphWeaver::Coerce.variable("login", OPERATION_NAME, login) { |v| GraphWeaver::Coerce.string(v) },
-      "first" => GraphWeaver::Coerce.variable("first", OPERATION_NAME, first) { |v| GraphWeaver::Coerce.integer(v) },
+      "login" => GraphWeaver::Coerce.variable("login", OPERATION_NAME, login) { |v| GraphWeaver::Coerce.string(v, "String") },
+      "first" => GraphWeaver::Coerce.variable("first", OPERATION_NAME, first) { |v| GraphWeaver::Coerce.integer(v, "Int") },
     }
 
     from_response(dispatch(variables, client:))

data/lib/graph_weaver/client.rb

@@ -190,6 +190,29 @@ class GraphWeaver::Client
     run(query, **variables).data!
   end
 
+  # Does this query validate? The string form of GraphWeaver.check_queries,
+  # answering with the same JSON-ready hashes — `message`, `line`, `column`,
+  # plus `subgraphs` where a supergraph brands them — so an empty array means
+  # it validates:
+  #
+  #      client.check_query("query { viewer { login } }")   # => []
+  #      client.check_query("query { viewer { lgoin } }")
+  #      # => [{ "message" => "Field 'lgoin' doesn't exist on type 'User'",
+  #      #      "line" => 1, "column" => 17 }]
+  #
+  # Checked against this client's own schema — what `execute` would run
+  # against — so a url client introspects on first use as it always does, and
+  # nothing re-introspects the way check_queries defaults to. An unparseable
+  # source is an entry like any other; nothing here raises for a bad query.
+  # Shared fragments are inlined from fragments: the same way every other door
+  # inlines them.
+  def check_query(source, fragments: GraphWeaver.fragments_paths)
+    GraphWeaver::Internal::QueryCheck.errors(
+      schema, source, GraphWeaver::Codegen.load_fragments(fragments),
+      GraphWeaver::Internal::QueryCheck.routing_table_for(schema_source),
+    )
+  end
+
   private
 
   # Anything already speaking the client contract — another Client,

data/lib/graph_weaver/codegen/emit.rb

@@ -97,7 +97,7 @@ class GraphWeaver::Codegen
     # both reference it by that name.
     def shared_enum_names
       @mapped_enums.each_value.flat_map { |m| ["#{m.const_prefix}_FROM_WIRE", "#{m.const_prefix}_TO_WIRE"] } +
-        @enums.each_value.map(&:class_name)
+        @enums.each_value.flat_map { |e| e.aliased? ? [e.class_name, e.alias_const] : [e.class_name] }
     end
 
     # Inputs: only the variable root types — the names this module's own
@@ -340,9 +340,17 @@ class GraphWeaver::Codegen
       end
       out << "#{pad}  end"
       out << "#{pad}end"
+      return unless node.aliased?
+
+      out << "#{pad}# wire spellings read as another value of #{node.class_name} (register_enum alias:)"
+      out << "#{pad}#{node.alias_const} = T.let({"
+      node.aliases.each { |from, to| out << "#{pad}  #{from.inspect} => #{to.inspect}," }
+      out << "#{pad}}.freeze, T::Hash[String, String])"
     end
 
-    # module-level wire translation tables for an app-mapped enum
+    # module-level wire translation tables for an app-mapped enum. TO_WIRE is
+    # written out rather than inverted from FROM_WIRE: an alias puts two
+    # spellings on one member, and only one of them goes back out.
     def emit_mapped_enum(node, out, indent)
       pad = "  " * indent
       type = node.bare_type
@@ -354,7 +362,11 @@ class GraphWeaver::Codegen
         out << "#{pad}  #{wire.inspect} => #{type}.deserialize(#{member.serialize.to_s.inspect}),"
       end
       out << "#{pad}}.freeze, T::Hash[String, #{type}])"
-      out << "#{pad}#{prefix}_TO_WIRE = T.let(#{prefix}_FROM_WIRE.invert.freeze, T::Hash[#{type}, String])"
+      out << "#{pad}#{prefix}_TO_WIRE = T.let({"
+      node.to_wire.each do |member, wire|
+        out << "#{pad}  #{type}.deserialize(#{member.serialize.to_s.inspect}) => #{wire.inspect},"
+      end
+      out << "#{pad}}.freeze, T::Hash[#{type}, String])"
     end
 
     def emit_object(node, out, indent)
@@ -383,7 +395,10 @@ class GraphWeaver::Codegen
       node.fields.each do |field|
         note = renamed_note(field.prop, field.key)
         out << "#{pad}  #{note}" if note
-        out << "#{pad}  const :#{field.prop}, #{field.node.prop_type}"
+        # a prop satisfying a mixin's abstract sig has to declare the override,
+        # and a `const` says it as a rule — there is no sig to put it in
+        override = node.overrides.include?(field.prop) ? ", override: true" : ""
+        out << "#{pad}  const :#{field.prop}, #{field.node.prop_type}#{override}"
       end
 
       out << ""
@@ -418,7 +433,7 @@ class GraphWeaver::Codegen
       # selected field onto the struct, next to the honest wire data
       node.aliases.each do |a|
         out << ""
-        out << "#{pad}  sig { returns(#{a.type}) }"
+        out << "#{pad}  sig { #{"override." if node.overrides.include?(a.name)}returns(#{a.type}) }"
         out << "#{pad}  def #{a.name} = #{a.expr}"
       end
       out << "#{pad}end"
@@ -677,13 +692,13 @@ class GraphWeaver::Codegen
         out << "#{pad}  const :#{field.prop}, #{type}#{default}"
       end
       out << ""
-      out << "#{pad}  # (prop, wire, required, serializer, coercer, coordinate) per field"
+      out << "#{pad}  # (prop, wire, required, serializer, coercer, coordinate, type) per field"
       out << "#{pad}  FIELDS = T.let(["
       node.fields.each do |field|
         serializer = field.node.serialize_identity? ? "nil" : "->(v) { #{field.node.serialize("v", 1)} }"
         coercer = field.node.hash_coerce_identity? ? "nil" : "->(v) { #{field.node.hash_coerce("v", 1)} }"
         coordinate = "#{node.graphql_name}.#{field.wire}"
-        out << "#{pad}    GraphWeaver::InputStruct::Field.new(:#{field.prop}, #{field.wire.inspect}, #{field.required}, #{serializer}, #{coercer}, #{coordinate.inspect}),"
+        out << "#{pad}    GraphWeaver::InputStruct::Field.new(:#{field.prop}, #{field.wire.inspect}, #{field.required}, #{serializer}, #{coercer}, #{coordinate.inspect}, #{field.type.inspect}),"
       end
       out << "#{pad}  ].freeze, T::Array[GraphWeaver::InputStruct::Field])"
       # InputStruct reads it with const_get, which privacy doesn't block

data/lib/graph_weaver/codegen/enum_type.rb

@@ -2,8 +2,8 @@
 # frozen_string_literal: true
 
 class GraphWeaver::Codegen
-  # How one GraphQL enum maps onto an app-owned T::Enum, so generated
-  # code speaks YOUR enum instead of generating one per module:
+  # What a register_enum said about one GraphQL enum: the app-owned T::Enum
+  # its values map onto, and which wire spellings are the same value.
   #
   #      class PetKind < T::Enum
   #        enums { Cat = new("cat"); Dog = new("dog") }
@@ -17,11 +17,23 @@ class GraphWeaver::Codegen
   # value the schema declares must resolve — generation fails naming the
   # gaps — unless fallback: names a member to absorb unknown values
   # (forward-compat for servers that add members; inputs stay strict).
+  #
+  # alias: { "legacy_mode" => "LEGACY_MODE" } says two wire values are one
+  # value — both spellings cast, the target is what serializes. It is the
+  # whole registration when there is no T::Enum to map onto, and then the
+  # generated enum gets one constant for the target and none for the alias.
   class EnumType
     attr_reader :graphql_name, :type, :fallback, :requires
 
-    def initialize(graphql_name, type, map: nil, fallback: nil, requires: nil)
+    def initialize(graphql_name, type, map: nil, fallback: nil, requires: nil, aliases: nil)
       @graphql_name = graphql_name.to_s
+      @aliases = normalize_aliases!(aliases)
+      @type = type
+      @map = map || {}
+      @fallback = fallback
+
+      return alias_only!(map, fallback, requires) if type.nil?
+
       # A name, not the class, is what you write when the constant won't
       # resolve yet — which in Rails means a config/initializers file, since
       # autoloading is set up after those run. Say where it does resolve.
@@ -36,9 +48,6 @@ class GraphWeaver::Codegen
         raise ArgumentError, "type: must be a named constant (anonymous classes can't appear in generated source)"
       end
 
-      @type = type
-      @map = map || {}
-      @fallback = fallback
       @requires = GraphWeaver::Codegen.normalize_requires!(requires, load: true)
 
       if fallback && !type.values.include?(fallback)
@@ -46,28 +55,128 @@ class GraphWeaver::Codegen
       end
     end
 
-    # wire value => member for every value the schema declares; raises
-    # naming the unmappable ones (unless fallback: absorbs them)
-    def mapping_for(wire_values)
-      mapping = {}
+    # The wire tables for a mapped enum: [wire value => member, member => the
+    # wire value that goes out]. Every spelling casts; an alias's target is the
+    # one that serializes.
+    def tables_for(wire_values)
+      aliases = aliases_for(wire_values)
+      from_wire = {}
       missing = []
 
       wire_values.each do |wire|
-        member = @map[wire] || infer(wire)
-        member ? mapping[wire] = member : missing << wire
+        canonical = aliases.fetch(wire, wire)
+        member = @map[canonical] || infer(canonical)
+        member ? from_wire[wire] = member : missing << canonical
       end
 
       if missing.any? && !fallback
         raise GraphWeaver::Error,
-          "#{type} has no member for #{graphql_name} value(s) #{missing.join(", ")} — " \
+          "#{type} has no member for #{graphql_name} value(s) #{missing.uniq.join(", ")} — " \
           "add them, pin with map:, or absorb with fallback:"
       end
 
-      mapping
+      [from_wire, to_wire(from_wire, aliases)]
+    end
+
+    # alias spelling => the value it is read as, checked against what the
+    # schema declares — an alias for or onto a value that isn't there is a
+    # registration this schema disproves.
+    def aliases_for(wire_values)
+      declared = wire_values.sort.join(", ")
+
+      @aliases.each do |from, to|
+        unless wire_values.include?(from)
+          raise GraphWeaver::Error,
+            "enum #{graphql_name} has no value #{from.inspect} to alias — its values are #{declared}; " \
+            "fix the spelling or drop the alias"
+        end
+        unless wire_values.include?(to)
+          raise GraphWeaver::Error,
+            "enum #{graphql_name}: alias #{from.inspect} => #{to.inspect} names no value of #{graphql_name} — " \
+            "its values are #{declared}; the target is the spelling that goes on the wire"
+        end
+      end
+
+      @aliases
+    end
+
+    # The register_enum a set of indistinguishable wire values needs, ready to
+    # paste. SCREAMING_CASE is the GraphQL convention, so the odd spelling is
+    # guessed as the alias — every caller's sentence says to check the direction.
+    def self.alias_suggestion(graphql_name, groups, type = nil)
+      pairs = groups.flat_map { |group|
+        target = group.find { |value| value == value.upcase } || group.first
+        (group - [target]).map { |value| "#{value.inspect} => #{target.inspect}" }
+      }
+
+      "GraphWeaver.register_enum(#{graphql_name.inspect}#{type ? ", #{type}" : ""}, " \
+        "alias: { #{pairs.join(", ")} })"
     end
 
     private
 
+    # Without a T::Enum there is nothing for map:/fallback:/requires: to
+    # describe, so alias: is the whole registration.
+    def alias_only!(map, fallback, requires)
+      if @aliases.empty?
+        raise ArgumentError, "register_enum(#{graphql_name.inspect}) says nothing about #{graphql_name} — " \
+          "pass the T::Enum to map it onto, or alias: { \"old\" => \"NEW\" } to read two wire values as one"
+      end
+
+      extra = { map:, fallback:, requires: }.compact.keys.first
+      if extra
+        raise ArgumentError,
+          "register_enum(#{graphql_name.inspect}, alias: {...}) takes no #{extra}: — that describes a T::Enum " \
+          "of your own, so pass one: register_enum(#{graphql_name.inspect}, YourEnum, alias: {...})"
+      end
+
+      @requires = []
+    end
+
+    # Sorted so generated source is stable across registration order.
+    def normalize_aliases!(aliases)
+      return {} if aliases.nil?
+
+      unless aliases.is_a?(Hash)
+        raise ArgumentError, "alias: is a hash of wire value => wire value, got #{aliases.inspect}"
+      end
+
+      pairs = aliases.to_h { |from, to| [from.to_s, to.to_s] }
+
+      self_alias = pairs.find { |from, to| from == to }
+      if self_alias
+        raise ArgumentError, "register_enum(#{graphql_name.inspect}): alias #{self_alias.first.inspect} => " \
+          "#{self_alias.last.inspect} reads a value as itself — drop it"
+      end
+
+      chained = pairs.keys.find { |from| pairs.value?(from) }
+      if chained
+        raise ArgumentError, "register_enum(#{graphql_name.inspect}): #{chained.inspect} is both an alias and " \
+          "the value an alias points at — an alias can't chain; point every spelling at the one that goes on the wire"
+      end
+
+      pairs.sort.to_h
+    end
+
+    # member => the one wire value it serializes to. Two spellings on one
+    # member with no alias saying which goes out is ambiguous — invert used to
+    # pick whichever came last, which for a deprecation pair was the dead one.
+    def to_wire(from_wire, aliases)
+      canonical = from_wire.except(*aliases.keys)
+      ambiguous = canonical.group_by { |_, member| member }.select { |_, pairs| pairs.size > 1 }
+      if ambiguous.any?
+        member, = ambiguous.first
+        groups = ambiguous.values.map { |pairs| pairs.map(&:first) }
+        more = ambiguous.size - 1
+        raise GraphWeaver::Error,
+          "enum #{graphql_name}: #{groups.first.join(" and ")} both map onto the #{type} member " \
+          "#{member.serialize.to_s.inspect}#{" (and #{more} more)" unless more.zero?} — say which spelling " \
+          "goes on the wire:\n  #{EnumType.alias_suggestion(graphql_name, groups, type)}"
+      end
+
+      canonical.invert
+    end
+
     # "CAT" matches serialize "cat"; "NOT_FOUND" matches "not_found"
     def infer(wire)
       @type.values.find { |member| normalize(member.serialize.to_s) == normalize(wire) }
@@ -80,19 +189,23 @@ class GraphWeaver::Codegen
 
   # The enum half of one graph's registrations — see Codegen::Registry.
   class Registry
-    # Map a GraphQL enum onto an app-owned T::Enum (see EnumType). The one
-    # implementation — GraphWeaver.register_enum is a delegate, so the same
-    # call reaches it whichever door you came in by.
+    # Map a GraphQL enum onto an app-owned T::Enum, or fold two of its wire
+    # spellings into one value (see EnumType). The one implementation —
+    # GraphWeaver.register_enum is a delegate, so the same call reaches it
+    # whichever door you came in by.
     #
     # A value map is a natural third *positional* guess, and Ruby's arity
     # complaint ("given 3, expected 2") never mentions the keyword.
-    def register_enum(graphql_name, type, positional_map = nil, map: nil, fallback: nil, requires: nil)
+    def register_enum(graphql_name, type = nil, positional_map = nil, map: nil, fallback: nil, requires: nil,
+      alias: nil)
       if positional_map
         raise GraphWeaver::Error, "register_enum: the value map is a keyword — " \
           "register_enum(#{graphql_name.inspect}, #{type}, map: {...})"
       end
 
-      enum_registry[graphql_name.to_s] = EnumType.new(graphql_name, type, map:, fallback:, requires:)
+      # `alias` is a Ruby keyword, so the parameter is only readable through binding
+      aliases = binding.local_variable_get(:alias)
+      enum_registry[graphql_name.to_s] = EnumType.new(graphql_name, type, map:, fallback:, requires:, aliases:)
     end
 
     def enum_registry

data/lib/graph_weaver/codegen/nodes.rb

@@ -178,14 +178,16 @@ class GraphWeaver::Codegen
 
     attr_reader :class_name, :fields
     # the GraphQL type this struct was generated from, any registered helper
-    # modules to include, and any resolved alias delegators (see extend_type)
-    attr_accessor :graphql_type, :mixins, :aliases
+    # modules to include, any resolved alias delegators, and the member names a
+    # mixin declares abstract — Sorbet demands the override on those (extend_type)
+    attr_accessor :graphql_type, :mixins, :aliases, :overrides
 
     def initialize(class_name)
       @class_name = class_name
       @fields = []
       @mixins = []
       @aliases = []
+      @overrides = []
     end
 
     def bare_type = class_name
@@ -203,17 +205,23 @@ class GraphWeaver::Codegen
   end
 
   class EnumNode < Node
-    attr_reader :class_name, :values
+    attr_reader :class_name, :values, :aliases
 
-    def initialize(class_name, values)
+    def initialize(class_name, values, aliases = {})
       @class_name = class_name
       @values = values
+      @aliases = aliases
     end
 
     def bare_type = class_name
 
+    # wire spellings this enum reads as another of its values (register_enum
+    # alias:) — a module-level table, emitted beside the class
+    def aliased? = !@aliases.empty?
+    def alias_const = "#{GraphWeaver::Inflect.underscore(class_name).upcase}_ALIASES"
+
     def cast(expr, _depth)
-      "GraphWeaver::Hints.enum(#{class_name}, #{expr})"
+      "GraphWeaver::Hints.enum(#{class_name}, #{expr}#{", #{alias_const}" if aliased?})"
     end
 
     def serialize(expr, _depth)
@@ -227,7 +235,7 @@ class GraphWeaver::Codegen
     def coerce? = true
 
     def coerce(expr)
-      "GraphWeaver::InputStruct.enum(#{class_name}, #{expr})"
+      "GraphWeaver::InputStruct.enum(#{class_name}, #{expr}#{", #{alias_const}" if aliased?})"
     end
 
     def input_type = "T.any(#{class_name}, String)"
@@ -240,13 +248,13 @@ class GraphWeaver::Codegen
   # <NAME>_TO_WIRE constants translate at the boundary. fallback: makes
   # casting absorb unknown wire values (inputs stay strict).
   class MappedEnum < Node
-    attr_reader :graphql_name, :mapping
+    attr_reader :graphql_name, :mapping, :to_wire
 
     def initialize(enum_type, wire_values)
       @graphql_name = enum_type.graphql_name
       @type_name = enum_type.type.name
       @fallback = enum_type.fallback
-      @mapping = enum_type.mapping_for(wire_values)
+      @mapping, @to_wire = enum_type.tables_for(wire_values)
     end
 
     def const_prefix = GraphWeaver::Inflect.underscore(@graphql_name).upcase
@@ -379,7 +387,10 @@ class GraphWeaver::Codegen
   # Joins the coerce protocol so execute kwargs accept plain hashes,
   # normalized (and type-checked) through the generated .coerce.
   class InputNode < Node
-    Field = Struct.new(:prop, :wire, :node, :required)
+    # type: the schema's spelling of the field's type ("[Float!]!"), which a
+    # refusal reports — the Sorbet prop type is the library's vocabulary, not
+    # the caller's.
+    Field = Struct.new(:prop, :wire, :node, :required, :type)
 
     # graphql_name as well as class_name: a schema coordinate is spelled the
     # schema's way (pokemon_bool_exp.name), which camelize has already lost.